综合解释swoole的协程原理

这是我看来网上很多人的文章，综合理解的结果，如果有错的地方，欢迎留言指出，希望大家一起前进，不惜勿喷

协程的执行顺序

先来看看基础的例子:

go(function () {
    echo "hello go1 \n";
});

echo "hello main \n";

go(function () {
    echo "hello go2 \n";
});

go() 是 \Co::create() 的缩写, 用来创建一个协程, 接受 callback 作为参数, callback 中的代码, 会在这个新建的协程中执行.

备注: \Swoole\Coroutine 可以简写为 \Co

上面的代码执行结果:

root@b98940b00a9b /v/w/c/p/swoole# php co.php
hello go1
hello main
hello go2

执行结果和我们平时写代码的顺序, 好像没啥区别. 实际执行过程:

  • 运行此段代码, 系统启动一个新进程
  • 遇到 go(), 当前进程中生成一个协程, 协程中输出 heelo go1, 协程退出
  • 进程继续向下执行代码, 输出 hello main
  • 再生成一个协程, 协程中输出 heelo go2, 协程退出


我们来稍微改一改, 体验协程的调度:

 

use Co;

go(function () {
    Co::sleep(1); // 只新增了一行代码
    echo "hello go1 \n";
});

echo "hello main \n";

go(function () {
    echo "hello go2 \n";
});

\Co::sleep() 函数功能和 sleep() 差不多, 但是它模拟的是 IO等待(IO后面会细讲). 执行的结果如下:

root@b98940b00a9b /v/w/c/p/swoole# php co.php
hello main
hello go2
hello go1

怎么不是顺序执行的呢? 实际执行过程:

  • 运行此段代码, 系统启动一个新进程
  • 遇到 go(), 当前进程中生成一个协程
  • 协程中遇到 IO阻塞 (这里是 Co::sleep() 模拟出的 IO等待), 协程让出控制, 进入协程调度队列
  • 进程继续向下执行, 输出 hello main
  • 执行下一个协程, 输出 hello go2
  • 之前的协程准备就绪, 继续执行, 输出 hello go1

官方协程示例

 

 

echo "main start\n";
go(function () {
    echo "coro ".co::getcid()." start\n";
    co::sleep(.1);
    echo "coro ".co::getcid()." end\n";
});

echo "main flag\n";
go(function () {
    echo "coro ".co::getcid()." start\n";
    co::sleep(.1);
    echo "coro ".co::getcid()." end\n";
});

echo "end\n";
/*
main start
coro 1 start
main flag
coro 2 start
end
coro 1 end
coro 2 end
*/

 

相信看到这里大家还是能够理解，那么具体深入看swoole如何应用协程：

$server = new Swoole\Http\Server('127.0.0.1', 9501, SWOOLE_BASE);

#1
$server->on('Request', function($request, $response) {
    $mysql = new Swoole\Coroutine\MySQL();
    #2
    $res = $mysql->connect([
        'host' => '127.0.0.1',
        'user' => 'root',
        'password' => 'root',
        'database' => 'test',
    ]);
    #3
    if ($res == false) {
        $response->end("MySQL connect fail!");
        return;
    }
    $ret = $mysql->query('show tables', 2);
    $response->end("swoole response is ok, result=".var_export($ret, true));
});

$server->start();

 

运行过程

  • 调用onRequest事件回调函数时，底层会调用C函数coro_create创建一个协程（#1位置），同时保存这个时间点的CPU寄存器状态和ZendVM stack信息。
  • 调用mysql->connect时发生IO操作，底层会调用C函数coro_save保存当前协程的状态，包括Zend VM上下文以及协程描述信息，并调用coro_yield让出程序控制权，当前的请求会挂起（#2位置）
  • 协程让出程序控制权后，会继续进入EventLoop处理其他事件，这时Swoole会继续去处理其他客户端发来的Request
  • IO事件完成后，MySQL连接成功或失败，底层调用C函数coro_resume恢复对应的协程，恢复ZendVM上下文，继续向下执行PHP代码（#3位置）
  • mysql->query的执行过程与mysql->connect一致，也会进行一次协程切换调度
  • 所有操作完成后，调用end方法返回结果，并销毁此协程

 

理解：

request回调方法就相当于创建一个协程，而数据库连接/查询，redis等等都是io任务，相当于co::sleep,所以会挂起当前协程，进而当前的swoole进程处理别的客户的request

 

指出错误解释：

//需要获取redis内的数据和mysql里的数据
$http_server = new swoole_http_server('0.0.0.0', 9503);
$http_server->on('request',function($request, $response){
    $result = '';
    //获取redis的时间
    $redis = new Swoole\Coroutine\Redis();
    $redis->connect('127.0.0.1', 6379);
    $result .= 'redis:' . $redis->get($request->get['name']) . '<br>';
    //获取mysql的时间
    $mysql = new Swoole\Coroutine\Mysql();
    $res = $mysql->connect([
        'host' => '127.0.0.1',
        'port' => 3306,
        'user' => 'root',
        'password' => 'XXX',
        'database' => 'swoole',
        'charset' => 'utf8', //指定字符集
        'timeout' => 2,  // 可选：连接超时时间（非查询超时时间），默认为SW_MYSQL_CONNECT_TIMEOUT（1.0）
    ]);
    if($res){
        $result .= 'mysql:' . json_encode($mysql->query('select * from user where id = ' . $request->get['id']) );
    }
    //总时间 = max(time(redis),time(mysql));
    $response->header('Content-Type', 'text/html');
    $response->end($result);

});

$http_server->start();

 

看了上一个例子，很容易理解网上的这个例子的关于 //总时间 = max(time(redis),time(mysql)); 的解释是错误的，因为对于单个用户的request来说，时间并没有减少，还是time(redis) + time(mysql)

 

协程快在哪? 减少IO阻塞导致的性能损失

大家可能听到使用协程的最多的理由, 可能就是 协程快. 那看起来和平时写得差不多的代码, 为什么就要快一些呢? 一个常见的理由是, 可以创建很多个协程来执行任务, 所以快. 这种说法是对的, 不过还停留在表面.

首先, 一般的计算机任务分为 2 种:

  • CPU密集型, 比如加减乘除等科学计算
  • IO 密集型, 比如网络请求, 文件读写等

其次, 高性能相关的 2 个概念:

  • 并行: 同一个时刻, 同一个 CPU 只能执行同一个任务, 要同时执行多个任务, 就需要有多个 CPU 才行
  • 并发: 由于 CPU 切换任务非常快, 快到人类可以感知的极限, 就会有很多任务 同时执行 的错觉

了解了这些, 我们再来看协程, 协程适合的是 IO 密集型 应用, 因为协程在 IO阻塞 时会自动调度, 减少IO阻塞导致的时间损失.

我们可以对比下面三段代码:

  • 普通版: 执行 4 个任务
$n = 4;
for ($i = 0; $i < $n; $i++) {
    sleep(1);
    echo microtime(true) . ": hello $i \n";
};
echo "hello main \n";

root@b98940b00a9b /v/w/c/p/swoole# time php co.php
1528965075.4608: hello 0
1528965076.461: hello 1
1528965077.4613: hello 2
1528965078.4616: hello 3
hello main
real    0m 4.02s
user    0m 0.01s
sys     0m 0.00s
⏎
  • 单个协程版:
$n = 4;
go(function () use ($n) {
    for ($i = 0; $i < $n; $i++) {
        Co::sleep(1);
        echo microtime(true) . ": hello $i \n";
    };
});
echo "hello main \n";

root@b98940b00a9b /v/w/c/p/swoole# time php co.php
hello main
1528965150.4834: hello 0
1528965151.4846: hello 1
1528965152.4859: hello 2
1528965153.4872: hello 3
real    0m 4.03s
user    0m 0.00s
sys     0m 0.02s
⏎
  • 多协程版: 见证奇迹的时刻
$n = 4;
for ($i = 0; $i < $n; $i++) {
    go(function () use ($i) {
        Co::sleep(1);
        echo microtime(true) . ": hello $i \n";
    });
};
echo "hello main \n";

root@b98940b00a9b /v/w/c/p/swoole# time php co.php
hello main
1528965245.5491: hello 0
1528965245.5498: hello 3
1528965245.5502: hello 2
1528965245.5506: hello 1
real    0m 1.02s
user    0m 0.01s
sys     0m 0.00s
⏎

为什么时间有这么大的差异呢:

  • 普通写法, 会遇到 IO阻塞 导致的性能损失
  • 单协程: 尽管 IO阻塞 引发了协程调度, 但当前只有一个协程, 调度之后还是执行当前协程
  • 多协程: 真正发挥出了协程的优势, 遇到 IO阻塞 时发生调度, IO就绪时恢复运行

我们将多协程版稍微修改一下:

  • 多协程版2: CPU密集型
$n = 4;
for ($i = 0; $i < $n; $i++) {
    go(function () use ($i) {
        // Co::sleep(1);
        sleep(1);
        echo microtime(true) . ": hello $i \n";
    });
};
echo "hello main \n";

root@b98940b00a9b /v/w/c/p/swoole# time php co.php
1528965743.4327: hello 0
1528965744.4331: hello 1
1528965745.4337: hello 2
1528965746.4342: hello 3
hello main
real    0m 4.02s
user    0m 0.01s
sys     0m 0.00s
⏎

只是将 Co::sleep() 改成了 sleep(), 时间又和普通版差不多了. 因为:

  • sleep() 可以看做是 CPU密集型任务, 不会引起协程的调度
  • Co::sleep() 模拟的是 IO密集型任务, 会引发协程的调度

这也是为什么, 协程适合 IO密集型 的应用.

再来一组对比的例子: 使用 redis

// 同步版, redis使用时会有 IO 阻塞
$cnt = 2000;
for ($i = 0; $i < $cnt; $i++) {
    $redis = new \Redis();
    $redis->connect('redis');
    $redis->auth('123');
    $key = $redis->get('key');
}

// 单协程版: 只有一个协程, 并没有使用到协程调度减少 IO 阻塞
go(function () use ($cnt) {
    for ($i = 0; $i < $cnt; $i++) {
        $redis = new Co\Redis();
        $redis->connect('redis', 6379);
        $redis->auth('123');
        $redis->get('key');
    }
});

// 多协程版, 真正使用到协程调度带来的 IO 阻塞时的调度
for ($i = 0; $i < $cnt; $i++) {
    go(function () {
        $redis = new Co\Redis();
        $redis->connect('redis', 6379);
        $redis->auth('123');
        $redis->get('key');
    });
}

性能对比:

# 多协程版
root@0124f915c976 /v/w/c/p/swoole# time php co.php
real    0m 0.54s
user    0m 0.04s
sys     0m 0.23s
⏎

# 同步版
root@0124f915c976 /v/w/c/p/swoole# time php co.php
real    0m 1.48s
user    0m 0.17s
sys     0m 0.57s
⏎


 

版权声明：本文为qq_16059847原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。