Swoole入门教程（四）：协程的具体使用

1,246次阅读
没有评论

什么是协程

协程可以简单理解为线程，只不过这个线程是用户态的，不需要操作系统参与，创建销毁和切换的成本非常低，和线程不同的是协程没法利用多核 CPU 的，想利用多核 CPU 需要依赖 Swoole 的多进程模型，可以通过Swoole\Process来实现多进程运行。那么协程如何调度呢？
首先每个协程可以简单的理解为一个线程，大家知道多线程是为了提高程序的并发，同样的多协程也是为了提高并发。用户的每个请求都会创建一个协程，请求结束后协程结束，如果同时有成千上万的并发请求，某一时刻某个进程内部会存在成千上万的协程，那么 CPU 资源是有限的，到底执行哪个协程的代码？

  • 首先，在执行某个协程代码的过程中发现这行代码遇到了 Co::sleep() 或者产生了网络 IO，例如 MySQL->query()，这肯定是一个耗时的过程，Swoole 就会把这个 MySQL 连接的 Fd 放到 EventLoop 中。
    • 然后让出这个协程的 CPU 给其他协程使用：即 yield(挂起)
    • 等待 MySQL 数据返回后再继续执行这个协程：即 resume(恢复)
  • 其次，如果协程的代码有 CPU 密集型代码，可以开启 enable_preemptive_scheduler，Swoole 会强行让这个协程让出 CPU。 
    ini_set('enable_preemptive_scheduler','On')

    Swoole之前的半自动化协程

    为了更好的理解协程，我们先看一段原生PHP代码

    <?php
$timeStart = microtime(true);
function task1(){
for ($i=0;$i<=300;$i++){
//写入文件,大概要3000微秒
usleep(3000);
echo "写入文件{$i}\n";
}
}
function task2(){
for ($i=0;$i<=500;$i++){
//发送邮件给500名会员,大概3000微秒
usleep(3000);
echo "发送邮件{$i}\n";
}
}
function task3(){
for ($i=0;$i<=100;$i++){
//模拟插入100条数据,大概3000微秒
usleep(3000);
echo "插入数据{$i}\n";
}
}
task1();
task2();
task3();
echo '总用时：'.microtime(true)-$timeStart."\n";

    在这个代码中,我们主要做了3件事:写入文件,发送邮件,以及插入数据，我们可以看到执行都是顺序运行的。
    Swoole入门教程（四）：协程的具体使用，先写入文件，再发送邮件，再插入数据。
    如果我们通过PHP生成器实现协程，代码大概是这样子。

    
<?php
$timeStart = microtime(true);
function task1(){
for ($i=0;$i<=30;$i++){
    //写入文件,大概要3000微秒
    usleep(3000);
    yield "写入文件{$i}\n";
}
}
function task2(){
for ($i=0;$i<=50;$i++){
    //发送邮件给500名会员,大概3000微秒
    usleep(3000);
    yield "发送邮件{$i}\n";
}
}
function task3(){
for ($i=0;$i<=10;$i++){
    //模拟插入100条数据,大概3000微秒
    usleep(3000);
    yield "插入数据{$i}\n";
}
}

class Task {
public $i_task_id;
public $g_coroutine;
public $m_send_value;
public $b_is_first_yield = true;
public function __construct( $i_task_id, Generator $g_coroutine ) {
$this->g_coroutine = $g_coroutine;
$this->i_task_id = $i_task_id;
}
public function set_send_value( $m_send_value ) {
$this->m_send_value = $m_send_value;
}
public function get_task_id() {
return $this->i_task_id;
}
public function run() {
// 如果是第一次执行yield
// 第一个yield的值要用current方法返回
if ( true === $this->b_is_first_yield ) {
$this->b_is_first_yield = false;
return $this->g_coroutine->current();
}
// 只要不是第一次yield，剩下的值都用send双向通道里获取到
else {
$m_yield_ret = $this->g_coroutine->send( $this->m_send_value );
$this->m_send_value = null;
return $m_yield_ret;
}
}
// 注意这个方法的内在逻辑是这样的
// 如果说当前的coroutine是可用的，那么就表示「还没有结束」
// 如果说当前的coroutine是不可用的，那么就表示「已经结束了」
// 所以，前面要取反，加上!
public function is_finish() {
return !$this->g_coroutine->valid();
}
}
class Scheduler {
public $i_current_task_id = 0; // 任务管理器当前最大的任务id
public $a_task_map = array();

// 创建一个新的调度器，就是初始化一个array用来存储task对象
public function __construct() {
    $this->a_task_map = array();
}

public function new_task( Generator $g_coroutine ) {
    $i_task_id = $this->i_current_task_id++;
    $o_task    = new Task( $i_task_id, $g_coroutine );
    $this->a_task_map[ $i_task_id ] = $o_task;
    return $i_task_id;
}

public function run() {
    while ( count( $this->a_task_map ) > 0 ) {
        $o_task = array_shift( $this->a_task_map );
        $result = $o_task->run();
        echo $result;
        if ( $o_task->is_finish() ) {
            unset( $this->a_task_map[ $o_task->get_task_id() ] );
        }
        else {
            array_push( $this->a_task_map, $o_task );
        }
    }
}

}

$scheduler = new Scheduler();
$scheduler->new_task( task1() );
$scheduler->new_task( task2() );
$scheduler->new_task( task3() );
$scheduler->run();

echo '总用时：'.microtime(true)-$timeStart."\n";

运行结果：
![协程](data:image/png;base64,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 "协程")

但是我们发现整个代码虽然协程化了，但执行速度并没有提升。**而swoole的协程可以直接提升执行效率**
```php
<?php
use Swoole\Coroutine;
use function Swoole\Coroutine\run;
$timeStart = microtime(true);
function task1(){
    for ($i=0;$i<=10;$i++){
        //写入文件,大概要3000微秒
        usleep(3000);
        echo "写入文件{$i}\n";
    }
}
function task2(){
    for ($i=0;$i<=50;$i++){
        //发送邮件给500名会员,大概3000微秒
        usleep(3000);
        echo "发送邮件{$i}\n";
    }
}
function task3(){
    for ($i=0;$i<=10;$i++){
        //模拟插入100条数据,大概3000微秒
        usleep(3000);
        echo "插入数据{$i}\n";
    }
}

run(function (){
    Coroutine::create(function (){
        task1();
    });
    Coroutine::create(function (){
        task2();
    });
    Coroutine::create(function (){
        task3();
    });
});

echo &#039;总用时：&#039;.microtime(true)-$timeStart."\n";</code></pre>
<p>copy上面代码去运行一下，你就会感受到效率的大幅提升。现在你可以感受到为什么要Swoole了，因为如果要原生PHP，我们需要编写任务类，也要编写调度器Scheduler，非常麻烦，在swoole中，直接用run包装一下就是，其实，run内部也运行了一个调度器<strong>Coroutine\Scheduler</strong></p>
<pre><code class="language-php">function run(callable $fn, ...$args)
{
    $s = new Scheduler();
    $options = Coroutine::getOptions();
    if (!isset($options[&#039;hook_flags&#039;])) {
        $s->set([&#039;hook_flags&#039; => SWOOLE_HOOK_ALL]);
    }
    $s->add($fn, ...$args);
    return $s->start();
}</code></pre>
<p>，只不过官方称这个调度器为<strong>协程容器。</strong>
<a name="ceQpC"></a></p>
<h1>协程容器</h1>
<p>在Swoole中，所有的协程必须在协程容器里面创建才行，Swoole 程序启动的时候大部分情况会自动创建协程容器，<strong> Swoole 启动协程容器的方式一共有四种</strong>：</p>
<ul>
<li>1、我们之前讲Swoole服务端的时候，<strong>Swoole\Server及其子类</strong>，在start后，会在事件回调中默认自动创建协程容器，除非我们手动设置了enable_coroutine属性为false，正常情况下我们不会这么做，但如果要如果要自己手动实现更细粒度的协程的话，可以通过go方法去创建协程，如：
<pre><code class="language-php">
$server = new Swoole\Http\Server("127.0.0.1", 9501);</code></pre></li>
</ul>
<p>$server->set([
//关闭内置协程
&#039;enable_coroutine&#039; => false,
]);</p>
<p>$server->on("request", function ($request, $response) {
if ($request->server[&#039;request_uri&#039;] == &#039;/coro&#039;) {
//关闭内置协程后，自己去实现协程
go(function () use ($response) {
co::sleep(0.2);
$response->header("Content-Type", "text/plain");
$response->end("Hello World\n");
});
} else {
$response->header("Content-Type", "text/plain");
$response->end("Hello World\n");
}
});</p>
<p>$server->start();</p>
<pre><code>
- 2、 Swoole 提供的 2 个进程管理模块 Process 和 Process\Pool，当构造方法里面设置了enable_coroutine为true，启动方式会在进程启动的时候创建协程容器，如：
```php
for ($n = 1; $n <= 3; $n++) {
    $process = new Process(function () use ($n) {
        echo 'Child #' . getmypid() . " start and sleep {$n}s" . PHP_EOL;
        sleep($n);
        echo 'Child #' . getmypid() . ' exit' . PHP_EOL;
    },false,SOCK_DGRAM,true);//enable_coroutine为true

    $process->start();
}
  • 3、我们常用的直接裸写协程的方式启动程序，使用run方法，如： 
    
use Swoole\Coroutine\Http\Server;
use function Swoole\Coroutine\run;

run(function () {
$server = new Server('127.0.0.1', 9502, false);
$server->handle('/', function ($request, $response) {
$response->end("<h1>Index</h1>");
});
$server->handle('/test', function ($request, $response) {
$response->end("<h1>Test</h1>");
});
$server->handle('/stop', function ($request, $response) use ($server) {
$response->end("<h1>Stop</h1>");
$server->shutdown();
});
$server->start();

});
echo 1;//得不到执行直到run里面的任务结束

> 注意：不可以嵌套 Coroutine\run()。如果嵌套，将得到：PHP Warning:  swoole\Coroutine\Scheduler::start(): eventLoop has already been created
Coroutine\run() 里面的逻辑如果有未处理的事件在 Coroutine\run() 之后就进行 EventLoop了，后面的代码将得不到执行，反之，如果没有事件了将继续向下执行，可以再次 Coroutine\run()。

- 4、run方法只是一个包装，可以通过new一个Coroutine\Scheduler来实现更细粒度的协程容器配置，如
```php
use Swoole\Coroutine;

$scheduler = new Coroutine\Scheduler;
$scheduler->add(function ($a, $b) {
    Coroutine::sleep(5);
    echo assert($a == &#039;hello&#039;) . PHP_EOL;
    echo assert($b == 12345) . PHP_EOL;
    echo "Done.\n";
}, "hello", 12345);
$scheduler->add(function (){
    Coroutine::sleep(1);
    echo &#039;i just sleep 1&#039;.PHP_EOL;
});
$scheduler->start();</code></pre>
<blockquote>
<p>Scheduler里面添加的协程函数一般不会立即执行，需要等待start后才会开始执行。</p>
</blockquote>
<p><a name="EQMGb"></a></p>
<h1>协程</h1>
<p><a name="guiCR"></a></p>
<h2>协程的创建</h2>
<p>在协程容器中，可以通过以下方法创建一个新协程。<br />1、Swoole\Coroutine::create(callable$function,...$args):int|false<br />2、go(callable$function,...$args):int|false// 参考php.ini的use_shortname配置<br />实际上go就是Coroutine::create的缩写</p>
<pre><code class="language-php">function go(callable $fn, ...$args)
{
    return Coroutine::create($fn, ...$args);
}</code></pre>
<p>代码：</p>
<pre><code class="language-php">run(function (){
    $cid = go(function (){
        echo &#039;aaaa&#039;.PHP_EOL;
    });
    echo $cid.PHP_EOL;
});
echo microtime(true) - $start;</code></pre>
<p><a name="cfHJX"></a></p>
<h2>协程的执行顺序</h2>
<p>使用go嵌套创建协程时，子协程会优先执行，子协程执行完毕或挂起时，将重新回到父协程向下执行代码，如果子协程挂起后，父协程退出，不影响子协程的执行</p>
<pre><code class="language-php">use Swoole\Coroutine;
use function Swoole\Coroutine\run;
use function Swoole\Coroutine\go;
$start = microtime(true);
run(function() {
    go(function () {
//        Coroutine::sleep(2.0);
        go(function () {
//            Coroutine::sleep(3.0);
            echo "co[3] end\n";
        });
        echo "co[2] end\n";
    });

//    Coroutine::sleep(1.0);
    echo "co[1] end\n";
});</code></pre>
<p>上面的代码，co[3]比co[1]先执行，上面的代码将输出<br />co[3] end<br />co[2] end<br />co[1] end<br />如果注释掉Coroutine::sleep，根据挂起的时间不同，将输出<br />co[1] end<br />co[2] end<br />co[3] end
<a name="dWRbY"></a></p>
<h2>协程的开销</h2>
<p>我们先跑一段php代码</p>
<pre><code class="language-php"><?php
$start_mem = memory_get_usage();
$start_time = microtime(true);
for($i=0;$i<10000;$i++){
    file_put_contents(&#039;defer.log&#039;,$i.PHP_EOL,FILE_APPEND);
}
$end_mem = memory_get_usage();
echo "use time".microtime(true)-$start_time.", use mem : ".( $end_mem - $start_mem ) / 1024 .&#039;kbytes&#039;.PHP_EOL;
</code></pre>
<p>结果如下：<br /><img src="data:image/png;base64,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" alt="内存的使用" title="内存的使用" /><br />再跑一段swoole代码</p>
<pre><code class="language-php"><?php
use function Swoole\Coroutine\run;
use function Swoole\Coroutine\go;
$start_mem = memory_get_usage();
$start_time = microtime(true);
run(function (){
    go(function (){
        for($i=0;$i<1000;$i++){
        file_put_contents(&#039;defer.log&#039;,$i.PHP_EOL,FILE_APPEND);
        }
    });
    go(function (){
        for($i=1000;$i<5000;$i++){
            file_put_contents(&#039;defer.log&#039;,$i.PHP_EOL,FILE_APPEND);
        }
    });
    go(function (){
        for($i=5000;$i<10000;$i++){
            file_put_contents(&#039;defer.log&#039;,$i.PHP_EOL,FILE_APPEND);
        }
    });
});

$end_mem = memory_get_usage();
echo "use time".microtime(true)-$start_time.", use mem : ".( $end_mem - $start_mem ) / 1024 .&#039;kbytes&#039;.PHP_EOL;
</code></pre>
<p>结果<br /><img src="data:image/png;base64,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" alt="内存增加了" title="内存增加了" /><br />说明用上swoole后，速度快了，但内存开销也增加了。</p>
<blockquote>
<p>每个协程都是相互独立的，需要创建单独的内存空间 (栈内存)，在 PHP-7.2 版本中底层会分配 8K 的 stack 来存储协程的变量，zval 的尺寸为 16字节，因此 8K 的 stack 最大可以保存 512 个变量。协程栈内存占用超过 8K 后 ZendVM 会自动扩容。<strong>协程退出时会释放申请的 stack 内存。</strong></p>
</blockquote>
<p><a name="En4kc"></a></p>
<h2>资源的释放</h2>
<p>当我们通过Swoole进行Mysql、redis操作之后，协程结束之后要及时关闭释放资源。不然久而久之会吧内存耗尽。Swoole的defer 方法用于资源的释放，会在<strong>协程关闭之前</strong> (即协程函数执行完毕时) 进行调用，就算抛出了异常，已注册的 defer 也会被执行。</p>
<pre><code class="language-php">go(function () {
    defer(function () use ($db) {
        $db->close();
    });
});</code></pre>
<p>当然，当我们使用Swoole内置的连接池时，Swoole已经帮我们做好了这部分的工作了，当我们需要自定义自己的连接池时需要及时释放资源。
<a name="KdgHv"></a></p>
<h2>协程Id和协程父Id</h2>
<p>1、Swoole使用<strong>getCid</strong>()获取当前协程的<strong>唯一 ID</strong>, 它的别名为 getuid, 是一个进程内唯一的正整数。当代码不在协程环境中会返回-1。<br />2、Swoole使用<strong>getPcid</strong>来获取当前协程的<strong>父Id</strong>，<strong>getPcid</strong>也可以接收一个cid参数来获取指定协程的<strong>父Id</strong></p>
<pre><code class="language-php"><?php
use Swoole\Coroutine;
use function Swoole\Coroutine\run;
use function Swoole\Coroutine\go;
$start = microtime(true);
run(function() {

    go(function () {
        go(function () {
            echo Coroutine::getCid().PHP_EOL;
            echo Coroutine::getPcid().PHP_EOL;
            echo "co[3] end\n";
        });

        echo Coroutine::getCid().PHP_EOL;
        echo Coroutine::getPcid(3).PHP_EOL;//返回null，因为协程3已经结束
        echo Coroutine::getPcid(2).PHP_EOL;//返回1
        echo "co[2] end\n";
    });
    echo Coroutine::getCid().PHP_EOL;
    echo "co[1] end\n";
});
echo Coroutine::getCid().PHP_EOL;</code></pre>
<p>以上代码输出<br /><img src="data:image/png;base64,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" alt="image.png" />
<a name="EH0vw"></a></p>
<h2>判断指定协程是否存在</h2>
<p>Swoole使用<strong>exists</strong>来判断指定的协程是否存在。不入cid参数时默认指定当前协程。</p>
<pre><code class="language-php"><?php
use Swoole\Coroutine;
use function Swoole\Coroutine\run;
use function Swoole\Coroutine\go;
run(function () {
    go(function () {
        go(function () {
            Coroutine::sleep(0.001);
            $pid = Coroutine::getPcid();
            echo "父Id：{$pid}，当前Id：".Coroutine::getCid().PHP_EOL;
            var_dump(Coroutine::exists($pid)); // 1：第一次输出true,因为父协程2还存在
        });
        go(function () {
            Coroutine::sleep(0.003);
            $pid = Coroutine::getPcid();
            echo "父Id：{$pid}，当前Id：".Coroutine::getCid().PHP_EOL;
            var_dump(Coroutine::exists($pid)); // 4：第四次输出false，这时父协程2已经走完了，结束了
        });
        Coroutine::sleep(0.002);
        $pid = Coroutine::getPcid();
        echo $pid.PHP_EOL;
        var_dump(Coroutine::exists($pid)); // 2: 第二次输出false，父协程1也就是run函数已经走完了。
        var_dump(Coroutine::exists(4));// 3:第三次输出true,这时协程Id4还是存在的
    });
});</code></pre>
<p>以上代码将输出<br /><img src="data:image/png;base64,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" alt="协程id" title="协程id" />
<a name="JUVS1"></a></p>
<h2>协程上下文对象</h2>
<p>我们先测试一段代码</p>
<pre><code class="language-php"><?php
use Swoole\Coroutine;

$http = new Swoole\Http\Server(&#039;0.0.0.0&#039;, 9501);
$_POST = [];
$http->on(&#039;Request&#039;, function (Swoole\Http\Request $request, Swoole\Http\Response $response) {
    global $_POST;
    $uri = $request->server[&#039;request_uri&#039;];
    $_POST[&#039;var&#039;] = $request->post[&#039;hello&#039;];
    if($uri == &#039;/a&#039;){
        Coroutine::sleep(5);//这时可能在请求数据库
        echo "/a 收到请求：参数是:".$_POST[&#039;var&#039;]."\n";
    }
    elseif($uri == &#039;/b&#039;){
        echo "/b 收到请求：参数是:".$_POST[&#039;var&#039;]."\n";
    }else{

    }
    $response->end("请求完成");
});
$http->set([
    &#039;worker_num&#039;=>1 //只用一个进程就好，方便测试
]);
$http->start();
</code></pre>
<p>启动服务之后，我们先访问/a<br />curl <a href="http://127.0.0.1:9501/a">http://127.0.0.1:9501/a</a> -X POST -d "hello=world"<br />然后再立即访问/b<br />curl <a href="http://127.0.0.1:9501/b">http://127.0.0.1:9501/b</a> -X POST -d "hello=world2"<br />得到的结果可能跟你们想的不一样。<br /><img src="data:image/png;base64,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" alt="协程上下文" title="协程上下文" /><br />两个请求都收到了world2，这就是协程间的变量污染，于是有了<strong>getContext</strong>。<br />使用<strong>getContext</strong>可以获取当前或指定协程Id的上下文对象Context。Context有如下特点</p>
<ul>
<li>协程退出后上下文自动清理 (如无其它协程或全局变量引用)</li>
<li>无 defer 注册和调用的开销 (无需注册清理方法，无需调用函数清理)</li>
<li>无 PHP 数组实现的上下文的哈希计算开销 (在协程数量巨大时有一定好处)</li>
<li>Co\Context 使用 ArrayObject, 满足各种存储需求 (既是<strong>对象</strong>，也可以以数组方式操作)
<blockquote>
<p>在Server开发中，通常会在一个时间周期内处理多个协程（或直接理解为请求）的代码，也就意味着如果使用了全局变量来储存状态可能会被多个协程所使用，也就是说不同的请求之间可能会混淆数据，这里的全局变量指的是 $_GET/$_POST/$_REQUEST/$_SESSION/$_COOKIE/$_SERVER等$_开头的变量、global 变量，以及 static 静态属性。<strong>但是在协程间的切换是隐式发生的，所以在协程切换的前后不能保证全局变量以及 static 变量的一致性。</strong>所以在 Swoole 内，<strong>无法 通过 $_GET/$_POST/$_REQUEST/$_SESSION/$_COOKIE/$_SERVER 等以 $_开头的变量获取到任何属性参数。</strong>但是，通过<strong>getContext</strong>获取到Context是相互独立的，所以我们可以将原来$_开头的变量存储到Context中，<strong>以保证这些变量不会别别的协程污染</strong></p>
</blockquote></li>
</ul>
<p>在很多Swoole框架中，一般都会吧Request对象和Response对象保存到基于协程Id来做隔离的Context中管理。</p>
<pre><code class="language-php">class Context
{
    protected static $nonCoContext = [];

    public static function set(string $id, $value)
    {
        if (Context::inCoroutine()) {
            Coroutine::getContext()[$id] = $value;
        } else {
            static::$nonCoContext[$id] = $value;
        }
        return $value;
    }

    public static function get(string $id, $default = null, $coroutineId = null)
    {
        if (Context::inCoroutine()) {
            if ($coroutineId !== null) {
                return Coroutine::getContext($coroutineId)[$id] ?? $default;
            }
            return Coroutine::getContext()[$id] ?? $default;
        }

        return static::$nonCoContext[$id] ?? $default;
    }

    public static function has(string $id, $coroutineId = null)
    {
        if (Context::inCoroutine()) {
            if ($coroutineId !== null) {
                return isset(Coroutine::getContext($coroutineId)[$id]);
            }
            return isset(Coroutine::getContext()[$id]);
        }

        return isset(static::$nonCoContext[$id]);
    }

    /**
     * Release the context when you are not in coroutine environment.
     */
    public static function destroy(string $id)
    {
        unset(static::$nonCoContext[$id]);
    }

    /**
     * Retrieve the value and override it by closure.
     */
    public static function override(string $id, \Closure $closure)
    {
        $value = null;
        if (self::has($id)) {
            $value = self::get($id);
        }
        $value = $closure($value);
        self::set($id, $value);
        return $value;
    }

    public static function inCoroutine(): bool
    {
        return Coroutine::getCid() > 0;
    }
}
</code></pre>
<p><a name="sO91F"></a></p>
<h2>协程的调度</h2>
<p>每个协程可以简单的理解为一个线程，多线程是为了提高程序的并发，同样的多协程也是为了提高并发。用户的每个请求都会创建一个协程，请求结束后协程结束，如果同时有成千上万的并发请求，某一时刻某个进程内部会存在成千上万的协程，那么 CPU 资源是有限的，到底执行哪个协程的代码？<br />决定到底让 CPU 执行哪个协程的代码的决断过程就是<strong>协程调度</strong>，Swoole 的调度策略又是怎么样的呢？</p>
<ul>
<li>1，在执行某个协程代码的过程中发现这行代码遇到了 Co::sleep() 或者产生了网络 IO，例如 MySQL->query()，这肯定是一个耗时的过程，Swoole 就会把这个 MySQL 连接的 Fd 放到 <a href="https://wiki.swoole.com/#/learn?id=%e4%bb%80%e4%b9%88%e6%98%afeventloop">EventLoop</a> 中。然后然后让出这个协程的 CPU 给其他协程使用，</li>
<li>2，如果协程的代码有 CPU 密集型代码，并且开启了 enable_preemptive_scheduler，Swoole 会强行让这个协程让出 CPU。</li>
<li>3，如果网络IO结束或者Mysql查询结束，调度程序就会恢复原来被挂起的协程继续执行。</li>
<li>4、如果协程内遇到手动挂起的代码（即yield）,调度程序也会让出CPU</li>
</ul>
<p>yield方法手动让出当前协程的执行权。而不是基于 IO 的协程调度，此方法拥有另外一个别名：Coroutine::suspend()</p>
<pre><code class="language-php">$cid = go(function () {
    echo "co 1 start\n";
    Co::yield();
    echo "co 1 end\n";
});

go(function () use ($cid) {
    echo "co 2 start\n";
    Co::sleep(0.5);
    Co::resume($cid);
    echo "co 2 end\n";
});
Swoole\Event::wait();</code></pre>
<p>resume方法手动恢复某个协程，使其继续运行。</p>
<blockquote>
<p>当前协程处于挂起状态时，另外的协程中可以使用 resume 再次唤醒当前协程</p>
</blockquote>
<p><a name="K0HzA"></a></p>
<h2>获取协程状态</h2>
<p>可以使用stats方法获取协程状态，统计协程的当前运行情况</p>
<pre><code class="language-php">var_dump(Swoole\Coroutine::stats());

array(1) {
  ["c_stack_size"]=>
  int(2097152)
  ["coroutine_num"]=>
  int(132)
  ["coroutine_peak_num"]=>
  int(2)
}</code></pre>
<p><a name="UoWy9"></a></p>
<h2>取消协程</h2>
<p>cancel方法用于取消某个协程，但不能对当前协程发起取消操作，手动取消正常结束，将返回 true, 如失败将返回 false，协程取消后，可以使用isCanceled方法来判断协程是否被手动取消。</p>
<pre><code class="language-php">use Swoole\Coroutine;
use function Swoole\Coroutine\run;
use function Swoole\Coroutine\go;

run(function () {
    $cid = Coroutine::getCid();
    var_dump($cid);
    go(function () use ($cid) {
        Coroutine::sleep(0.005);
        $toCancel = go(function (){
            Coroutine::sleep(1);
            $cid = Coroutine::getCid();
            echo $cid.PHP_EOL;
        });
        go(function () use ($toCancel){
            var_dump(Coroutine::cancel($toCancel));//true
            var_dump(Coroutine::cancel(1));//false 1已经结束了

        });
    });

    echo "Done\n";
});</code></pre>
<p><a name="OOh20"></a></p>
<h2>协程的并发执行</h2>
<p>Swoole使用<strong>batch</strong>函数并发执行多个协程，并且通过数组，返回这些协程方法的返回值</p>
<pre><code class="language-php"><?php
use function Swoole\Coroutine\run;
use function Swoole\Coroutine\batch;
run(function () {
    $use = microtime(true);
    $results = batch([
        &#039;gethostbyname&#039; => function () {
            return gethostbyname(&#039;localhost&#039;);
        },
        &#039;file_get_contents&#039; => function () {
            return file_get_contents(__DIR__ . &#039;/defer.log&#039;);
        },
        &#039;sleep&#039; => function () {
            sleep(5);
            return true;
        },
        &#039;usleep&#039; => function () {
            usleep(10000);
            return true;
        },
    ], 0.1);
    $use = microtime(true) - $use;
    echo "Use {$use}s, Result:\n";
    var_dump($results);
});</code></pre>
<p>当不需要返回执行结果时，可以使用<strong>parallel方法。</strong></p>
<pre><code class="language-php"><?php

use Swoole\Coroutine;
use Swoole\Coroutine\System;
use function Swoole\Coroutine\parallel;

$start_time = microtime(true);
Coroutine\run(function () {
    $use = microtime(true);
    $results = [];
    parallel(2, function () use (&$results) {
        System::sleep(0.2);
        $results[] = System::gethostbyname(&#039;localhost&#039;);
    });
    $use = microtime(true) - $use;
    echo "Use {$use}s, Result:\n";
    var_dump($results);
});
$end_time =  microtime(true) - $start_time;
echo "Use {$end_time}s, Done\n";</code></pre>
<p><a name="taw5F"></a></p>
<h1>协程间通讯</h1>
<p>协程都是相互独立的，那么他们之间如何通讯呢？使用<strong>Coroutine\Channel</strong><br /><strong>Coroutine\Channel</strong>，官方称之为<strong>通道</strong>，用于协程间通讯，支持多生产者协程和多消费者协程。底层自动实现了协程的切换和调度</p>
<ul>
<li>通道与 PHP 的 Array 类似，仅占用内存，没有其他额外的资源申请，所有操作均为内存操作，无 IO 消耗</li>
<li>底层使用 PHP 引用计数实现，无内存拷贝。即使是传递巨大字符串或数组也不会产生额外性能消耗</li>
<li>channel 基于引用计数实现，是零拷贝的</li>
</ul>
<p>Channel使用方法与 SplQueue 队列类似：</p>
<ul>
<li>Channel->push ：当队列中有其他协程正在等待 pop 数据时，自动按顺序唤醒一个消费者协程。当队列已满时自动 yield 让出控制权，等待其他协程消费数据</li>
<li>Channel->pop ：当队列为空时自动 yield，等待其他协程生产数据。消费数据后，队列可写入新的数据，自动按顺序唤醒一个生产者协程。
<pre><code class="language-php">
<?php</code></pre></li>
</ul>
<p>use Swoole\Coroutine;
use Swoole\Coroutine\Channel;
use function Swoole\Coroutine\run;</p>
<p>run(function(){
$channel = new Channel(1);
Coroutine::create(function () use ($channel) {
for($i = 0; $i < 10; $i++) {
Coroutine::sleep(1.0);
$channel->push([&#039;rand&#039; => rand(1000, 9999), &#039;index&#039; => $i]);//在第一个协程中，生产数据
echo "{$i}\n";
}
});
Coroutine::create(function () use ($channel) {
while(1) {
$data = $channel->pop(2.0);//在第二个协程中消费数据，设置为2秒超时，如果2秒内管道内没有数据，就退出
if ($data) {
var_dump($data);
} else {
assert($channel->errCode === SWOOLE_CHANNEL_TIMEOUT);
break;
}
}
});
});</p>
<pre><code><a name="JzKyP"></a>
## 协程间的并发控制
假设我们写了个爬虫，要爬取了淘宝和百度的首页，我们哗啦哗啦写下了如下代码：
```php
<?php
use Swoole\Coroutine;
use Swoole\Coroutine\WaitGroup;
use Swoole\Coroutine\Http\Client;
use function Swoole\Coroutine\run;

function getConent($domain){
    //启动一个协程客户端client，请求淘宝首页

    $cli = new Client($domain, 443, true);
    $cli->setHeaders([
        'Host' => $domain,
        'User-Agent' => 'Chrome/49.0.2587.3',
        'Accept' => 'text/html,application/xhtml+xml,application/xml',
        'Accept-Encoding' => 'gzip',
    ]);
    $cli->set(['timeout' => 1]);
    $cli->get('/index.php');

    $result = $cli->body;
    $cli->close();
    return $result;
}

run(function () {
    $result = [];
    Coroutine::create(function () use ( &$result) {
        $result['baidu'] = getConent('www.baidu.com');
    });
    Coroutine::create(function () use ( &$result) {
        $result['taobao'] = getConent('www.taobao.com');
    });
    var_dump($result);
});

初看这段代码，如果你认为$result能打印出内容，那么你的技术还有待加强，实际上result打印出来是空数组。
因为你打印时子协程还在拼命挖矿中。要打印出内容，有2种方法，1、分别在28行和31行打印。2、33行的上面sleep一下，让父协程等待子协程完成但要sleep多久了，睡得太久，那效率太低，睡得太少，那么子协程可能还没挖到矿。这时如果有WaitGroup加持，就可以解决这个问题。

WaitGroup

WaitGroup 是基于 Channel 衍生出来的一个特性，如果接触过 Go 语言，我们都会知道 WaitGroup 这一特性，WaitGroup 的用途是使得主协程一直阻塞等待直到所有相关的子协程都已经完成了任务后再继续运行，这里说到的阻塞等待是仅对于主协程（即当前协程）来说的，并不会阻塞当前进程。有了WaitGroup，上面的代码可以改为这样

<?php
use Swoole\Coroutine;
use Swoole\Coroutine\WaitGroup;
use Swoole\Coroutine\Http\Client;
use Swoole\Coroutine\Channel;
use function Swoole\Coroutine\run;

function getConent($domain){
    //启动一个协程客户端client，请求淘宝首页
    $cli = new Client($domain, 443, true);
    $cli->setHeaders([
        'Host' => $domain,
        'User-Agent' => 'Chrome/49.0.2587.3',
        'Accept' => 'text/html,application/xhtml+xml,application/xml',
        'Accept-Encoding' => 'gzip',
    ]);
    $cli->set(['timeout' => 1]);
    $cli->get('/index.php');

    $result = $cli->body;
    $cli->close();
    return $result;
}

run(function () {
    $wg = new WaitGroup();
    $result = [];
    $wg->add();
    //启动第一个协程
    Coroutine::create(function () use ($wg, &$result) {
        $result['baidu'] = getConent('www.baidu.com');
        $wg->done();
    });

    $wg->add();
    //启动第二个协程
    Coroutine::create(function () use ($wg, &$result) {
        $result['taobao'] = getConent('www.taobao.com');
        $wg->done();
    });

    //挂起当前协程，等待所有任务完成后恢复
    $wg->wait();
    //这里 $result 包含了 2 个任务执行结果
    var_dump($result);
});

Barrier

在 Swoole 中底层提供了一个更便捷的协程并发管理工具：Coroutine\Barrier 协程屏障，或者叫协程栅栏。基于 PHP 引用计数和 Coroutine API 实现。相比于 Coroutine\WaitGroup，Coroutine\Barrier 使用更简单一些，只需通过参数传递或者闭包的 use 语法，引入子协程函数上即可。

<?php
use Swoole\Coroutine;
use Swoole\Coroutine\WaitGroup;
use Swoole\Coroutine\Http\Client;
use Swoole\Coroutine\Barrier;
use function Swoole\Coroutine\run;

function getConent($domain)
{
    //启动一个协程客户端client，请求淘宝首页
    $cli = new Client($domain, 443, true);
    $cli->setHeaders([
        'Host' => $domain,
        'User-Agent' => 'Chrome/49.0.2587.3',
        'Accept' => 'text/html,application/xhtml+xml,application/xml',
        'Accept-Encoding' => 'gzip',
    ]);
    $cli->set(['timeout' => 1]);
    $cli->get('/index.php');

    $result = $cli->body;
    $cli->close();
    return $result;
}

run(function () {
    $barrier = Barrier::make();
    $result = [];
    //启动第一个协程
    Coroutine::create(function () use ($barrier, &$result) {
        $result['baidu'] = getConent('www.baidu.com');
    });

    //启动第二个协程
    Coroutine::create(function () use ($barrier, &$result) {
        $result['taobao'] = getConent('www.taobao.com');
    });

    //挂起当前协程，等待所有任务完成后恢复
    Barrier::wait($barrier);
    //这里 $result 包含了 2 个任务执行结果
    var_dump($result);
});

本篇就先写到这吧啊，以后老俊有时间的话会再继续写swoole序列，文章内容都是根据老俊的学习所得，如有不当，还请多多指正。

正文完
swoole 协程
发表至： Php Swoole
2023-08-28
 

公众号

最新文章

归档