Swoole4 使用全新的协程内核引擎，现在我们拥有一个全职的开发团队，因此我们正在进入 PHP 历史上前所未有的时期，为性能的高速提升提供了独一无二的可能性。

`Swoole4` 或更高版本拥有高可用性的内置协程，您可以使用`完全同步的代码`来实现`异步 IO`，PHP 代码没有任何额外的关键字，底层会自动进行协程调度。

### 1、使用协程你可以在一秒钟里做多少事？
睡眠 1 万次，读取，写入，检查和删除文件 1 万次，使用 PDO 和 MySQLi 与数据库通信 1 万次，创建 TCP 服务器和多个客户端相互通信 1 万次，创建 UDP 服务器和多个客户端相互通信 1 万次...... 一切都在一个进程中完美完成！

###2、创建协程
协程的操作，依赖于`Swoole\Coroutine`组件，官方推荐使用`go()`函数，来代替`Swoole\Coroutine::create()`创建一个协程。

协程相关的手册：`https://wiki.swoole.com/#/coroutine/coroutine`

###3、协程开销
每个协程都是相互独立的，需要创建单独的内存空间 (栈内存)，在 `PHP-7.2` 版本中底层会分配 `8K` 的 `stack` 来存储协程的变量，zval 的尺寸为 `16字节`，因此 `8K` 的 `stack` 最大可以保存 `512` 个变量。协程栈内存占用超过 `8K` 后 `ZendVM` 会自动扩容。

协程退出时会释放申请的 `stack` 内存。

`PHP-7.1`、`PHP-7.0` 默认会分配 `256K` 栈内存

可调用 `Co::set(['stack_size' => 4096])` 修改默认的栈内存尺寸

###3、协程相关函数
下面函数是相对于`Swoole\Coroutine`类而言：
```
set() 协程设置
create() 创建一个新的协程，并立即执行。
defer() 用于资源的释放
exists() 判断指定协程是否存在
getCid() 获取当前协程的唯一 ID
getPcid() 获取当前协程的父 ID
getContext() 获取当前协程的上下文对象
yield() 手动让出当前协程的执行权。而不是基于 IO 的协程调度
resume() 手动恢复某个协程，使其继续运行，不是基于 IO 的协程调度
list() 遍历当前进程内的所有协程
stats() 获取协程状态
getBackTrace() 获取协程函数调用栈
getElapsed() 获取协程运行的时间以便于分析统计或找出僵尸协程
```

###4、执行顺序

在一个协程中使用 `go` 嵌套创建新的协程。因为 `Swoole` 的协程是单进程单线程模型，因此：

使用 `go` 创建的子协程会优先执行，子协程执行完毕或挂起时，将重新回到父协程向下执行代码。

如果子协程挂起后，父协程退出，不影响子协程的执行。
```
// 创建父协程：A
go(function() {
  // 子协程：B
  go(function () {
      // 2、再到我执行，但挂起3秒
      co::sleep(3.0);
      // 孙子协程：C
      go(function () {
          // 1、我先执行，但挂起2秒
          co::sleep(2.0);
          echo "我是C \n";
      });
      echo "我是B \n";
  });
  // 3、最后到我执行了，等待1秒
  co::sleep(1.0);
  echo "我是A \n";
});
```
最终结果为：
```
我是A
我是B
我是C
```
可能这时候很多人就蒙了，不是说子协程优先执行吗，怎么结果是反过来的？我们下面就来推理下真正的执行流程：
```
子孙线程C先执行，但它sleep(2.0)，执行权给回了父线程B
父线程B执行，但它又立刻执行了sleep(3.0)，执行权给回了爷爷线程A
爷爷线程A执行，但它又立刻执行了sleep(1.0)

所以整个程序的真正执行是
A->B>C

如果我们把全部睡眠器屏蔽掉，执行顺序就是：
C->B->A
```

###5、协程关闭、释放资源
很多时候，协程关闭之后，我们需要消耗一些内部打开的资源，例如连接池释放等操作。

Swooole提供了`Swoole\Coroutine::defer()`方法，支持该系列操作。

> 需要注意的是，它的调用顺序是逆序的（先进后出）, 也就是先注册 `defer` 的后执行，先进后出。逆序符合资源释放的正确逻辑，后申请的资源可能是基于先申请的资源的，如先释放先申请的资源，后申请的资源可能就难以释放。

例如下面的案例：
```
// 创建父协程：A
go(function() {
  // 我后走，因为协程关闭之后，才会触发我
  \Swoole\Coroutine::defer(function(){
    echo "妈耶，A执行完啦 \n";
  }); 
  // 我先走
  echo "我是A \n"; 
});
```
聪明的朋友这时候可能会疑惑，那如果协程挂起，会触发资源回收吗？我们尝试下：
```
// 创建父协程：A
go(function() {
  // 创建子协程：B
  go(function() {
    // 我后走，因为协程关闭之后，才会触发我
    \Swoole\Coroutine::defer(function(){
      echo "妈耶，A执行完啦 \n";
    }); 
    co::sleep(3.0);
    // 我先走
    echo "我是B \n"; 
  });
  
  echo "我是A \n";
});
```
得出的结果是：
```
我是A 
我是B 
妈耶，A执行完啦 
```
也就是说，协程的挂起并不会触发`defer()`，所以无需担心。

###6、获取当前协程的唯一ID
再Swoole中，子协程要想跟父协程交互，需要依赖`进程ID`通信，所以要先学习如何获取进程ID。

`go()`函数在成功创建协程后，会返回该协程的唯一ID。

然后我们也可以在协程内部，通过`Swoole\Coroutine::getCid()`，获取当前协程ID。

例如:
```
// 创建父协程：A
$aid = go(function(){
  // 创建子协程：B
  go(function() {
    $bid = \Swoole\Coroutine::getCid();
    echo "我是B，我的ID是：".$bid." \n";
  });

$aid = \Swoole\Coroutine::getCid();
  echo "我是A，我的ID是：".$aid." \n";
});

echo "父协程A的ID：".$aid." \n";
```

###7、获取当前父协程的唯一ID
我们在子协程的内部，是没办法通过匿名函数的`use ()`传递父协程的ID进去的，最多只能传递爷爷协程的ID，所以要想获得父协程的ID，Swoole提供了一个`Swoole\Coroutine::getPcid()`;

该方法可以传入一个协程的ID，用于获取该协程的父协程ID，如果不传入，则默认获取当前协程的父协程ID。

例如：
```
// 创建爷爷协程：A
$aid = go(function(){
  // 创建父协程：B
  go(function() {
    $bid = \Swoole\Coroutine::getCid();
    echo "我是B，我的ID是：".$bid." \n";
    echo '我爸爸的ID是：'.\Swoole\Coroutine::getPcid()."\n";
    // 创建孙子协程：C
    go(function() use($bid) {
      $cid = \Swoole\Coroutine::getCid();
      echo "我是C，我的ID是：".$cid." \n";
      echo '我爷爷的ID是：'.\Swoole\Coroutine::getPcid($bid)."\n";
    });
  });

$aid = \Swoole\Coroutine::getCid();
  echo "我是A，我的ID是：".$aid." \n";
});

echo "爷爷协程A的ID：".$aid." \n";
```

###8、判断指定协程是否存在
当我们多层，或多个协程同时使用时，可能会需要用到判断某个协程是否还在执行中，这时候就需要用到`Swoole\Coroutine::exists()`方法。

例如：
```
// 创建父协程：A
go(function() {
  // 子协程：B
  go(function () {
      // 孙子协程：C
      go(function () {
          echo "我是C \n";
          // 先挂起，让协程B先走
          Co::sleep(0.001);
          // 这时候我们会发现子协程已经执行完了，所以是false
          var_dump(Co::exists(Co::getPcid()));
      });
      echo "我是B \n";
      // 这里不挂起，协程A还没执行，所以是true
      var_dump(Co::exists(Co::getPcid()));
  });
  echo "我是A \n";
});
```

###9、获取当前协程的上下文对象
在swoole中,由于多个协程是并发执行的，因此不能使用类静态变量/全局变量保存协程上下文内容。

使用局部变量是安全的，因为局部变量的值会自动保存在协程栈中，其他协程访问不到协程的局部变量。

Swoole中获取协程上下文使用`Swoole\Coroutine::getContext()`方法，该方法可传入指定的协程ID，为空时表示当前协程。
如若需要同时操作多个协程上下文，可从传入一维数组。

作用：
```
协程退出后上下文自动清理 (如无其它协程或全局变量引用)
无 defer 注册和调用的开销 (无需注册清理方法，无需调用函数清理)
无 PHP 数组实现的上下文的哈希计算开销 (在协程数量巨大时有一定好处)
Co\Context 使用 ArrayObject, 满足各种存储需求 (既是对象，也可以以数组方式操作)
```
示例：
```
class test {

}
go(function() {
    $cid = Co::getCid(); // 得到当前协程id
    // 不传递 $cid,默认是当前协程id
    $context = Co::getContext($cid=null);
    // 保存属性到 协程上下文 Context 中
    $context["a"] = 1; 
    $context["b"] = 2;
    // 也可以时数组，也能是对象
    $context['test'] = new test();
    $context->test2 = new test();

//  在子协程中获取 示例
    go(function(){
      $cid = Co::getPcid(); // 获取父协程id
      $context = Co::getContext($cid);  // 得到 父协程中的 $context 变量
      var_dump($context);
    });

// 在父协程的另外一个作用域获取案例
    function test() {
      $cid = Co::getCid();
      $data = Co::getContext($cid);
      var_dump($data);
      return "test -> yes\n";
    }
    echo test();
});
```
###10、暂停当前协程
官方说法是手动让出当前协程的执行权。而不是基于 IO 的协程调度。

我们正常的理解，应该是暂停当前协程，并将他从底层的IP协程顺序中抽离。

使用方法为：`Swoole\Coroutine::yield()`，该方法还拥有另外一个别名：`Coroutine::suspend()`

> 注意：该方法必须与 `Coroutine::resume()` 方法成对使用。当协程 `yield` 以后，必须由其他外部协程 `resume`(重启)，否则将会造成协程泄漏，被挂起的协程永远不会执行。

示例：
```
$cid = go(function () {
  echo "co 1 start\n";
  // 先暂停
  co::yield();
  echo "co 1 end\n";
});

go(function () use ($cid) {
  echo "co 2 start\n";
  // 等待0.5秒
  co::sleep(0.5);
  // 重启cid协程
  co::resume($cid);
  echo "co 2 end\n";
});
```

### 11、重启某个协程
手动恢复某个协程，使其继续运行，不是基于 IO 的协程调度。

上面我们已经说过这个方法是用于重启已经`yield`的协程，但还有一个地方要注意，该方法重启的协程，并不是将协程回归底层的IO调度机制。

该方法为：`Swoole\Coroutine::resume()`，参数为需要唤醒的协程ID。

示例：
```
$aid = go(function () {
  echo "我是协程A ：start\n";
  // 先暂停
  co::yield();
  echo "协程A ：end\n";
  co::yield();
  echo "协程A ：我再次start了\n";
});
$bid = go(function () {
  echo "我是协程B ：start\n";
  // 先暂停
  co::yield();
  echo "协程B ：end\n";
});

go(function () use ($aid, $bid) {
  // 重启aid协程
  co::resume($aid);
  // 再次重启
  co::resume($aid);
  // 重启bid协程
  co::resume($bid);
});
```

###12、遍历当前进程内的所有协程
如果我们想自己试下协程管理器，可以使用这个方法，读取当前进程下的所有在线协程。

方法为：`Swoole\Coroutine::list()`，返回迭代器，可使用 `foreach` 遍历，或使用 `iterator_to_array` 转为数组。

示例：
```
$aid = go(function () {
  echo "我是协程A ：start\n";
  // 等待2秒
  co::sleep(2);
  echo "协程A ：end\n";
});
$bid = go(function () {
  echo "我是协程B ：start\n";
  // 等待2秒
  co::sleep(2);
  echo "协程B ：end\n";
});

echo "协程A ：{$aid}\n";
echo "协程B ：{$bid}\n";

$coros = Swoole\Coroutine::listCoroutines();
foreach ($coros as $cid) {
    var_dump($cid);
}
```
从上面的案例我们可以看出，其返回值的协程ID顺序，是先进后出。

###13、获取某个协程的状态
协程管理器的辅助方法，用该方法可以查看整个协程的工作副本信息。

方法为：`Swoole\Coroutine::stats()`，返回值是一个一维数组。

> 注意：该方法不是查询某个协程的状态，而是整个协程工作组的状态汇总。

返回值如下：

示例：
```
$aid = go(function () {
  echo "我是协程A ：start\n";
  go(function () {
    echo 'Oh ! NO~';
  });
  // 等待2秒
  co::sleep(2);
  echo "协程A ：end\n";
});
$bid = go(function () {
  echo "我是协程B ：start\n";
  // 等待2秒
  co::sleep(2);
  echo "协程B ：end\n";
});

var_dump(Swoole\Coroutine::stats());
```

###14、查看某个协程的调用栈
协程管理器的辅助方法，用该方法，可以查询某个协程的调用流程（官方称之为调用栈），该方法对已结束的协程无效。

方法：`Swoole\Coroutine::getBackTrace(int $cid=0, int $options=DEBUG_BACKTRACE_PROVIDE_OBJECT, int $limit=0)`；

参数：
```
int $cid
功能：协程的 CID
默认值：当前协程 CID
其它值：无

int $options
功能：设置选项
默认值：DEBUG_BACKTRACE_PROVIDE_OBJECT 【是否填充 object 的索引】
其它值：DEBUG_BACKTRACE_IGNORE_ARGS 【是否忽略 args 的索引，包括所有的 function/method 的参数，能够节省内存开销】

int *limit
功能：限制返回堆栈帧的数量
默认值：0
其它值：无
```
上面说的堆栈帧，其实是指返回的调用流程长度，返回的数组长度。返回值的格式为先进后出。

示例：
```
function test1() {
  test2();
}

function test2() {
  echo __FUNCTION__." \n";

$obj = new demo();
  $obj->run();
}

class demo{
  public function run(){
    echo 'demo->run();';

// 需要等待下，防止协程关闭了，调用栈就看不到了
    co::sleep(1);
  }
}

$cid = go(function () {
  test1();
});

go(function () use ($cid) {
    echo "BackTrace[$cid]:\n-----------------------------------------------\n";
    //返回数组，需要自行格式化输出
    var_dump(co::getBackTrace($cid))."\n";
});
```

###15、查看某个协程的运行时间
协程管理器的辅助方法，用该方法可以查看某个正在工作中的进程执行时间，以便于分析统计或找出僵尸协程。

方法：`Swoole\Coroutine::getElapsed()`，该方法需要传入一个协程ID。

示例：
```
$aid = go(function () {
  echo "start~\n";
  // 等待
  co::sleep(100);
  echo "end~\n";
});

go(function () use($aid) {
  // 这里要等待，不然看不出线程的执行时间
  co::sleep(1);
  var_dump(Swoole\Coroutine::getElapsed($aid)." 毫秒~");
});
```

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺