Asio无栈协程

对于Asio无栈协程做一个比较全面的导引,从使用、原理和实现三个方面进行叙述。

官方文档:Asio Stackless Coroutine

1 引入

Asio Stackless Coroutine不同于一般依赖编译器实现的无栈协程,其实现方式很巧妙,完全依赖c++本身的函数机制和语言特性实现(Duff's Device / switch)。

其初衷是 无缝结合asio的async api,同时屏蔽掉异步编程的复杂性,通过引入极少几个宏,提供一种简单的同步组织代码的方式。

使用传统的异步+回调,逻辑代码会被迫拆分成多段,通过多次回调才能完成一次逻辑,比如要发起一次http访问,代码可能像这样:

void DoHttpCall(string host) {
    // 解析域名,并注册下一步回调函数
    _resolver.async_resolve(host, "http", HandleResolve);
}
// 建立连接
void HandleResolve(const asio::error_code& ec,
    const tcp::resolver::results_type& endpoints){
    if (!ec){
      asio::async_connect(_socket, endpoints, HandleConnect);
    }
}
// 发送请求
void HandleConnect(const asio::error_code& ec){
    if (!ec){
        asio::async_write(_socket, _request, HandleWrite);
    }
}
// 读取响应并解析处理
void HandleWrite(const asio::error_code& ec) {
    // 通过async_read系列函数读取响应并解析
    // 后面应该还会有 反复多次 HandleReadLine 逐行解析http头部
    // 然后是 HandleContent 读取http body 等等调用
    // 此处略
}

如果使用asio无栈协程,则可以把所有逻辑流畅得放在一个函数里,代码会像这样(略去了错误处理):

void Do(std::shared_ptr<Context> client_ctx, asio::coroutine coro,
        asio::error_code ec, std::size_t length,
        asio::ip::tcp::resolver::results_type results) {

    auto gen_io_func = [&]() {
        return std::bind(&Do, client_ctx, coro, std::placeholders::_1,
                         std::placeholders::_2,
                         asio::ip::tcp::resolver::results_type());
    };

    reenter(coro) {
        // 解析域名
        yield {
            auto result_func =
                std::bind(&Do, client_ctx, coro, std::placeholders::_1, 0,
                          std::placeholders::_2);
            client_ctx->_resolver.async_resolve(client_ctx->_request._host,
                                                client_ctx->_request._port,
                                                result_func);
        }
        // 建立连接
        yield {
            auto conn_func =
                std::bind(&Do, client_ctx, coro, std::placeholders::_1, 0,
                          asio::ip::tcp::resolver::results_type());
            client_ctx->_socket.async_connect(*results, conn_func);
        }
        // 发送请求
        yield async_write(client_ctx->_socket, client_ctx->_request.ToBuffers(),
                          gen_io_func());

        client_ctx->_buffer.fill(0);
        // 读取并解析响应
        do {
            yield client_ctx->_socket.async_read_some(
                asio::buffer(client_ctx->_buffer), gen_io_func());
            std::tie(client_ctx->_valid_reply, std::ignore) =
                client_ctx->_reply_parser.Parse(
                    client_ctx->_reply, client_ctx->_buffer.data(),
                    client_ctx->_buffer.data() + length);
        } while (client_ctx->_valid_reply ==
                 ParseHelper::Result::indeterminate);
        // 处理响应
        // ...
    }
}

可以看到,使用了协程之后,所有的逻辑都被以同步的方式放在了一个函数中处理,其可维护性和可读性都有很大提升。
完整代码见这里.

2 使用

本章结合官方文档对协程所涉及的语法进行描述。对于官方文档中已经提及的内容,不会再重复赘述,更多是一些补充和扩展。

2.1 语法

基于asio::coroutine实现协程,每一个协程必定包含一个coroutine实例,一个包含reenter、yield的逻辑函数,一般如下:

class Session : asio::coroutine {
public:
    void operator()(error_code ec, std::size_t length = 0) {
        // 这里的逻辑,每次重新进入协程都会执行
        // 比如,可以在这里放置一些通用的错误处理逻辑
        if (!err) {
            // error handle
            return ;
        }

        // 协程内的具体业务逻辑要放在reenter内
        reenter(this) {
            // 记录当前位置,发起async_accept调用,并切出协程
            yield _acceptor->async_accept(_socket, *this);
            // 如果有连接进来,触发回调,回到此处继续执行

            // 记录当前位置,发起async_read调用,并切出协程
            yield _socket->async_read_some(asio::buffer(*_buffer), *this);
            // 如果有数据可读,触发回调,回到此处继续执行
        }

        // 这里的逻辑,每次切出协程均会执行
    }
};

下面对使用协程所涉及的各个关键字进行描述。

class coroutine

每个协程都需要存储其本身的状态,为此,有了class coroutine。coroutine类可以拷贝构造、可以赋值,其数据成员只有一个int,消耗很少。

class coroutine {
public:
  coroutine() : value_(0) {}
  /// Returns true if the coroutine is the child of a fork.
  bool is_child() const { return value_ < 0; }
  /// Returns true if the coroutine is the parent of a fork.
  bool is_parent() const { return !is_child(); }
  /// Returns true if the coroutine has reached its terminal state.
  bool is_complete() const { return value_ == -1; }
private:
  friend class detail::coroutine_ref;
  int value_;
};

coroutine一般有两种用法。一种是作为基类使用:

class session : coroutine {
    void operator()(error err);
    ...
};

或者作为类的一个成员变量:

class session {
    void operator()(error err);
    ...
    coroutine coro_;
};

具体的协程逻辑则在类的operator()运算符中实现。

这里思路可以放开一点,可以直接抛弃class,直接将其作为函数的一个参数,结合std::bind进行传递(可以参见上一节的代码片段)。只要在协程的存在期间,能够维持coroutine对象的拷贝即可,具体的方式并不重要。

void RunCoro(coroutine coro, error err);

reenter

reenter用来定义协程的主体,协程的主要逻辑要放在reenter限定的作用域内。

协程采用继承coroutine方式实现时,你的代码会像这样:

reenter (this) {
    // coroutine body
}

如果采用成员变量或者函数形式实现,则像这样:

reenter (_coro) {
    // coroutine body
}

后文提及的关键字(yield、fork)只能在reenter限定的范围内使用;这样才能保证协程重新切回后,能够继续之前的位置执行。另外,要注意,reenter是基于switch实现,所以在协程体内,有着和switch一样的限制,要时刻留意临时变量的定义问题。

yield

yield关键字的用法,官方文档描述的很清晰,不在此赘述。

  • yield statement ;
  • yield { statements }
  • yield return expression ;
  • yield ;
  • yield break ;

一个小的窍门是用yield {}来规避switch的局部变量限制:

yield {
    auto conn_func =
        std::bind(&Do, client_ctx, coro, std::placeholders::_1, 0,
                    asio::ip::tcp::resolver::results_type());
    client_ctx->_socket.async_connect(*results, conn_func);
}

要注意一个非常容易踩且比较隐晦的坑:

class downloader : asio::coroutine {
    using socket_t = boost::asio::ip::tcp::socket;
    using resolver_t = boost::asio::ip::tcp::resolver;

    std::shared_ptr<socket_t> socket_;
    std::shared_ptr<resolver_t> resolver_;

    const std::string file_;
    const std::string host_;
    size_t fileSize_{};

public:
    void operator()(error_code ec = error_code(), std::size_t length = 0,
                  const resolver_t::results_type &results = {}) {

        // Check if the last yield resulted in an error.
        if (ec &7 ec != eof) {
            throw std::runtime_error(ec.message());
        }

        // Jump to after the previous yield.
        reenter(this) {
            // 问题根源在这里
            yield {
                resolver_t::query query{host_, "80"};

                // Use bind to skip the length parameter not provided by async_resolve
                auto result_func = std::bind(&downloader::operator(), this, _1, 0, _2);

                resolver_->async_resolve(query, result_func);
            }

            // 这里会偶发段错误
            yield socket_->async_connect(*results, *this);

            // 略去其他逻辑
            //......
        }
    }

上面这段代码,将asio::coroutine作为基类来使用,然后重写了operator()运算符,通过传递*this拷贝类本身来传递coroutine实例,一切看起来很正确?
问题在于,这种基于基类的方式,和std::bind进行结合时,bind产生的可调用体中仅包含了this指针的拷贝,而不是类对象的拷贝。当类对象被释放后,这个this指针会变成野指针,在协程重新切回之后,下一次的async_connect(*results, *this),对一个野指针进行寻址访问,会发生什么,不必多说。

完整的错误示范可以见stackoverflow这个问题的accepted answer

要注意,这个回答是错的,是错的,是错的。

fork

fork关键字的用法,官方文档描述的很清晰,不在此赘述。

  • fork statement ;

fork一般会用在服务端,比如accept到新的连接,启动一个子协程去处理。

2.2 示例

这里给出两个示例,基本涵盖了asio::coroutine的所有用法。

基于asio::coroutine实现的http client
基于asio::coroutine实现的http server

3 原理

3.1 Duff设备与switch case的本质

Duff's Device

在上世纪,计算机单核性能较低,人们经常使用一种被称为“循环展开”的方式优化代码,使其在多核处理器和流水线处理器上性能更好。

简单来说,这样一段循环1000w次的代码:

int result = 0;
for (int i = 0; i < 10000000; ++i) {
    sum += i; 
}

可以修改成这样,只需要循环200w次即可:

int result = 0;
for (int i = 0; i < 2000000; i += 5) {
    result += i;
    result += i+1;
    result += i+2;
    result += i+3;
    result += i+4;
}

Duff在编写一个数组拷贝函数时(将from指针开始count个元素的内容拷贝到to数组),使用到了上述技术。但是,数组长度往往无法被循环展开的次数整除(count%8 != 0),这意味着除了一个while循环之外,还需要一个额外的switch来将n无法整除的部分单独执行。代码如下:

void copy(char *to, char *from, int count) {
    int n = (count + 7) / 8;
    switch (count % 8) {
        case 0: *to = *from++;
        case 7: *to = *from++;
        case 6: *to = *from++;
        case 5: *to = *from++;
        case 4: *to = *from++;
        case 3: *to = *from++;
        case 2: *to = *from++;
        case 1: *to = *from++;
    }
    while (--n > 0) {
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
    }
}

Duff稍加思索,将switch和while结合到一起,写出了如下的代码。

当函数开始执行时,会根据count%8算出的余数,跳转到case 0-7对应的代码执行,因为没有显式break,switch不会跳出,而是会继续执行跳转位置后方case的内容,这会完成无法整除部分的拷贝。直到执行到while语句,被循环捕获,进入while循环,这会完成整除部分的拷贝。

void copy(char *to, char *from, int count) {
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
            } while (--n > 0);
    }
}

switch case的本质

Duff's Device向我们揭示了这样一个事实:switch case后的语句,并没有我们想象中诸如代码块or作用域之类的限制,case的角色本质上是一种特殊的标签,可以在代码的任何地方放置case,且不会影响其他代码的执行。swtich的角色则是限定switch case标签的作用域,并且维护somthing like jump table,用于case匹配时的跳转。
如果你打开c标准Labeled statements一节,你会发现 标签、case、default 一同被归为标签语句。

可以试试这个hello world,体会一下switch case的行为。

#include <iostream>

using std::cout;
using std::endl;

int main(int argc, char *argv[]) {
    // int a(0);
    int a(1);
    switch (a) case(0):for(;;) {
        cout<<"hello"<<endl;
        case (1):
        cout<<"world"<<endl;
        return 0;
    }
}

3.2 基于switch case实现协程

asio::coroutine正是受Duff's Device的启发,基于switch case这一特性实现的,没有涉及任何汇编。

协程的切换方式其实和函数很像,但其对比函数的区别是,协程的重要特性是可以返回并继续,当协程被重新切回后,应该能从其切走时的位置继续执行。
如果要把一个函数改造为协程,一种朴素的想法是,给这个函数增加一个静态变量state,在所有函数要恢复执行的位置,放置一个label。并在函数切走之前,设置state的值标识切回后,函数继续执行的位置。比如这样:

假定这是一个需要循环对某个server发起心跳探活的函数实现:

void coro_func(error_code ec) {
    static int state = 0;
    switch(state) {
        case 0: goto LABEL0;
        case 1: goto LABEL1;
        case 2: goto LABEL2;
    }
LABEL0:
    for(;;) {
        // 发起连接
        state = 1;
        asio::async_connect(socket, endpoints, &coro_func);
        return;
LABEL1:
        // 写入数据
        state = 2;
        asio::async_write(socket, request, &coro_func);
        return;
LABEL2:
        // 读取响应并处理,略
        // sleep一段时间,略
    }
}

这样的“协程”稍显简陋,主要的问题在于,所有的label都要手动设置,并时刻需要维护switch与label的一致性。
现在是Duff's Device大展身手的时候了:

void coro_func(error_code ec) {
    static int state = 0;
    switch(state) {
        case 0:
        for(;;) {
            // 发起连接
            state = 1;
            asio::async_connect(socket, endpoints, &coro_func);
            return;
        case 1:
            // 写入数据
            state = 2;
            asio::async_write(socket, request, &coro_func);
            return;
        case 2:
            // 读取响应并处理,略
            // sleep一段时间,略
        }
    }
}

现在只剩下两个问题:

  1. 将函数开头用于保存恢复位置的静态变量state用其他方式实现(多线程成精局部静态变量是非线程安全的),可以考虑使用类成员变量,或者函数参数等方式记录状态
  2. 现在我们仍然需要手动编写switch case,更好的方式是基于__LINE__封装一组宏,自动实现跳转恢复的逻辑,以保证代码的可读性和易用性

来看看asio::coroutine是如何实现的。

4 实现

asio::coroutine代码非常少,全部代码不过100行,下面贴出代码,并在每个代码片段之前以及代码中的注释中给出解释。

在看代码之前,你要理清几点:

  1. 基于Duff's Device的协程,其本质上是可以恢复并继续执行的函数,每一次切出,都是正常的函数return
  2. 协程的恢复(切回),都是正常的函数调用,都会从协程函数的开头开始执行,执行到reenter时,通过reenter宏定义的switch,基于你传入的class corourine对象中的value_跳转到具体的case继续执行
  3. 函数的恢复(切回)这一行为的触发,asio::coroutine没有定义,如果结合asio使用,切回的实现,是将协程函数注册为async_xxx系列函数的回调,然后在事件ready后,回调触发协程恢复,这可以让coroutine和异步接口无缝衔接

class coroutine用于替代上一节中 静态变量 state 的作用,主要作用是通过value_成员记录协程恢复后继续执行的位置。
除此之外,还通过一些特殊的取值,比如-1来标识协程退出等状态(其实这些完全可以单独搞一个bool,放在一起是为了节省内存使用和拷贝的消耗)。

// 协程上下文
class coroutine {
public:
  /// Constructs a coroutine in its initial state.
  coroutine() : value_(0) {}

  // 用于在fork关键字后,区分当前是子协程还是父协程
  // 要注意的是,is_child只有在子协程第一次进入,没有执行过yield进行切出前有效
  // 一旦你进行了切出,子协程的value_也会被重置为正值
  // Returns true if the coroutine is the child of a fork.
  bool is_child() const { return value_ < 0; }
  // Returns true if the coroutine is the parent of a fork.
  bool is_parent() const { return !is_child(); }

  // value_如果等于-1 代表协程已经结束
  // 详见 ~coroutine_ref() 注释
  bool is_complete() const { return value_ == -1; }

private:
  friend class detail::coroutine_ref;
  int value_;
};

class coroutine 对象的生命周期贯穿整个协程,而coroutine_ref在每次进入协程时创建,在每次切出协程后释放。
同时协程中所有对class coroutine中value_的修改,都是通过coroutine_ref进行的。

// 一个对于class coroutine的引用类
class coroutine_ref {
public:
  // 从class coroutine对象构造
  coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
  coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}

  // 如果是通过yield临时切出协程,则一定会修改value_,即modified_一定为true
  // 只有通过return、抛出异常,或者函数正常执行到末尾退出协程函数,modified_才会是false
  // 即,当modifed_为false时,代表协程已经结束,此时将value_设为-1,表示协程已经complete
  ~coroutine_ref() { if (!modified_) value_ = -1; }

  // 如果对value_进行修改,同步将modified_设为true
  int& operator=(int v) { modified_ = true; return value_ = v; }

  operator int() const { return value_; }
private:
  void operator=(const coroutine_ref&);
  int& value_;
  bool modified_;
};

reenter 是所有协程都要包含的一个宏,用于开始协程体的定义,定义switch,以及一些特殊的case。

case 0后的逻辑在协程第一次进入时跳转执行。

如果是协程重新切回,则reenter中的switch会将其跳转到切出前的位置继续执行。

case -1后的逻辑,一方面,用于处理协程已经退出,但又被重新调度执行的情况;另一方面,可由其他位置的goto语句(比如yield)进入,执行协程切换时的退出逻辑。
terminate_coroutine 标签后的代码 定义了终止协程要做的逻辑。
bail_out_of_coroutine 标签后的代码 定义了退出协程要做的逻辑。

// reenter的实现
#define ASIO_CORO_REENTER(c) \
  switch (::asio::detail::coroutine_ref _coro_value = c) \
    case -1: if (_coro_value) \
    { \
      goto terminate_coroutine; \
      terminate_coroutine: \
      _coro_value = -1; \
      goto bail_out_of_coroutine; \
      bail_out_of_coroutine: \
      break; \
    } \
    else /* fall-through */ case 0:

#ifndef reenter
# define reenter(c) ASIO_CORO_REENTER(c)
#endif

yield 在需要临时切出当前协程,或者要终止协程时调用。

for (_coro_value = (n);;) 此类写法起到赋值并延展作用域的作用。

if (_coro_value == 0) 此判断永远为false,主动调用yield不会进入该分支,此分支判断中的代码,仅在协程切回,通过switch case jump进入执行。执行逻辑仅一个break,效果是跳出一开始的for作用域,直接继续执行yield语句后方的代码。

else switch (_coro_value ? 0 : 1)后的代码比较复杂,主要是为了实现yield的多种功能,在看这里的代码之前,先回顾下yield的几种用法。yield共有五种用法,在这里,我们把它分成两类:

  • 第一类
    • yield statement ;
    • yield { statements }
    • yield return expression ;
    • yield ;
  • 第二类
    • yield break ;

第一类,yield后跟一个用户自定义的语句或者空语句,此时yield的行为是:
记录当前的执行位置 -> 执行用户定义的语句 -> 跳出reenter限定的作用域执行函数末尾的代码然后返回
此后,协程如果被恢复执行,会接着yield下一行代码继续执行。

第二类,yield接break,此时的yield的行为是:
终止协程的运行(将value_设为-1) -> 跳出reenter限定的作用域执行函数末尾的代码然后返回
此后,协程完全终止,不再可以被恢复执行。

回到代码,else switch (_coro_value ? 0 : 1)中的_coro_value恒大于0,所以一定会跳到末尾的case 0执行,此时执行用户定义的语句。

  • 如果用户的语句是return,则临时切出协程,并返回一个值。
  • 如果用户的语句是break,则会跳出else for (;;) case 1:所在的for循环,进入for(;;) case -1:的循环,然后执行goto terminate_coroutine;,将value_设为0,标识协程终止,并跳出reenter作用域,执行函数末尾的逻辑,然后返回。
  • 如果用户的语句不是breakreturn,则执行完用户的语句后,会进入for (;;) case 1:所在for循环,然后执行goto bail_out_of_coroutine;,跳出reenter作用域,执行函数末尾的逻辑,然后返回。
// yield的实现
#define ASIO_CORO_YIELD_IMPL(n) \
  for (_coro_value = (n);;) \
    if (_coro_value == 0) \
    { \
      case (n): ; \
      break; \
    } \
    else \
      switch (_coro_value ? 0 : 1) \
        for (;;) \
          /* fall-through */ case -1: if (_coro_value) \
            goto terminate_coroutine; \
          else for (;;) \
            /* fall-through */ case 1: if (_coro_value) \
              goto bail_out_of_coroutine; \
            else /* fall-through */ case 0:

# define ASIO_CORO_YIELD ASIO_CORO_YIELD_IMPL(__LINE__)

#ifndef yield
# define yield ASIO_CORO_YIELD
#endif

fork 在创建子协程时调用。

仔细看代码,你会发现,这里没有做任何与fork相关的操作,创建和启动子协程的操作是由用户编写的。

这里做的仅仅是在执行用户提供的子协程代码之前,将coro_value改为负值;
用户的子协程构造代码,会把 class coroutine 拷贝一份,拷贝构造出的class coroutine中的value
即为负值。

在用户子协程函数返回之后,再把_coro_value改回正值,并继续后面的代码执行。

// fork的实现
#define ASIO_CORO_FORK_IMPL(n) \
  for (_coro_value = -(n);; _coro_value = (n)) \
    if (_coro_value == (n)) \
    { \
      case -(n): ; \
      break; \
    } \
    else

# define ASIO_CORO_FORK ASIO_CORO_FORK_IMPL(__LINE__)

#ifndef fork
# define fork ASIO_CORO_FORK
#endif
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 140,856评论 1 295
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 60,475评论 1 254
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 92,639评论 0 208
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 40,628评论 0 171
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 48,311评论 1 250
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 38,533评论 1 167
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,235评论 2 266
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,017评论 0 161
  • 想象着我的养父在大火中拼命挣扎,窒息,最后皮肤化为焦炭。我心中就已经是抑制不住地欢快,这就叫做以其人之道,还治其人...
    爱写小说的胖达阅读 28,738评论 6 225
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 32,358评论 0 211
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,115评论 2 211
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 30,444评论 1 222
  • 白月光回国,霸总把我这个替身辞退。还一脸阴沉的警告我。[不要出现在思思面前, 不然我有一百种方法让你生不如死。]我...
    爱写小说的胖达阅读 24,138评论 0 31
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 26,965评论 2 209
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 31,349评论 3 200
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,574评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 25,901评论 0 163
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 33,314评论 2 227
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 33,433评论 2 228

推荐阅读更多精彩内容