|
什么是协程
先搞清楚，什么是协程。
你可能已然听过『进程』和『线程』这两个概念。
进程便是二进制可执行文件在计算机内存里的一个运行实例，就好比你的.exe文件是个类，进程便是new出来的那个实例。
进程是计算机系统进行资源分配和调度的基本单位（调度单位这儿别纠结线程进程的），每一个CPU下同一时刻只能处理一个进程。
所说的并行，只不外是看起来并行，CPU事实上在用火速的速度切换区别的进程。
进程的切换需要进行系统调用，CPU要保留当前进程的各个信息，同期还会使CPUCache被废掉。
因此进程切换不到费不得已就不做。
那样怎么实现『进程切换不到费不得已就不做』呢？
首要进程被切换的要求是：进程执行完毕、分配给进程的CPU时间片结束，系统出现中断需要处理，或进程等待必要的资源（进程阻塞）等。你想下，前面几种状况自然无什么话可说，然则倘若是在阻塞等待，是不是就浪费了。
其实阻塞的话咱们的程序还有其他可执行的地区能够执行，不必定要傻傻的等！因此就有了线程。线程简单理解便是一个『微进程』，专门跑一个函数（规律流）。
因此咱们就能够在编写程序的过程中将能够同期运行的函数用线程来表现了。
线程有两种类型，一种是由于内核来管理和调度。
咱们说，只要触及需要内核参与管理调度的，代价都是很大的。这种线程其实亦就处理了当一个进程中，某个正在执行的线程遇到阻塞，咱们能够调度另一一个可运行的线程来跑，然则还是在同一个进程里，因此没有了进程切换。
还有另一一种线程，他的调度是由于程序员自己写程序来管理的，对内核来讲不可见。这种线程叫做『用户空间线程』。
协程能够理解便是一种用户空间线程。
协程，有几个特点： 协同，由于是由于程序员自己写的调度策略，其经过协作而不是抢占来进行切换在用户态完成创建，切换和销毁⚠️ 从编程方向上看，协程的思想本质上便是掌控流的主动让出（yield）和恢复（resume）机制迭代器经常用来实现协程说到这儿，你应该明白协程的基本概念了吧？
PHP实现协程
循序渐进来，从解释概念说起！
可迭代对象
PHP5供给了一种定义对象的办法使其能够经过单元列表来遍历，例如用foreach语句。
你倘若要实现一个可迭代对象，你就要实现Iterator接口： <?php
class MyIterator implements Iterator
{
private $var = array();
public function __construct($array)
{
if (is_array($array)) {
$this->var = $array;
}
}public function rewind() {
echo "rewinding\n";
reset($this->var);
}
public function current() {
$var = current($this->var);
echo "current: $var\n";
return $var;
}
public function key() {
$var = key($this->var);
echo "key: $var\n";
return$var;
}public function next() {
$var = next($this->var);
echo "next: $var\n";
return $var;
}
public function valid() {
$var = $this->current() !==false;
echo "valid: {$var}\n";
return $var;
}
}
$values = array(1,2,3);
$it = new MyIterator($values);
foreach($it as $a => $b) {print "$a: $b\n";
}
生成器
能够说之前为了持有一个能够被foreach遍历的对象，你不得不去实现一堆的办法，yield关键字便是为了简化这个过程。
生成器供给了一种更易的办法来实现简单的对象迭代，相比较定义类实现Iterator接口的方式，性能开销和繁杂性大大降低。 <?php
function xrange($start, $end, $step = 1) {
for ($i = $start; $i <= $end; $i += $step) {
yield $i;
}
}
foreach (xrange(1, 1000000) as $num) {
echo $num, "\n";
}
记住，一个函数中倘若用了yield，他便是一个生成器，直接调用他是无用的，不可等同于一个函数那样去执行！
因此，yield便是yield，下次谁再说yield是协程，我肯定把你xxxx。
PHP协程
前面介绍协程的时候说了，协程需要程序员自己去编写调度机制，下面咱们来看这个机制怎么写。
0）生成器正确运用
既然生成器不可像函数同样直接调用，那样怎么才可调用呢？
办法如下： foreach他send($value)current / next...1）Task实现
Task便是一个任务的抽象，刚才咱们说了协程便是用户空间协程，线程能够理解便是跑一个函数。
因此Task的构造函数中便是接收一个闭包函数，咱们命名为coroutine。 /**
* Task任务类
*/
class Task
{
protected $taskId;
protected $coroutine;
protected$beforeFirstYield =true;
protected $sendValue;
/**
* Task constructor.
* @param $taskId
* @param Generator $coroutine
*/
public function __construct($taskId, Generator $coroutine)
{
$this->taskId = $taskId;
$this->coroutine = $coroutine;
}
/**
* 获取当前的Task的ID
*
*@return mixed
*/
public function getTaskId()
{
return $this->taskId;
}
/**
* 判断Task执行完毕了无
*
* @returnbool
*/
public function isFinished()
{
return !$this->coroutine->valid();
}
/**
* 设置下次要传给协程的值，例如 $id = (yield $xxxx)，这个值就给了$id了
*
*@param $value
*/
public function setSendValue($value)
{
$this->sendValue = $value;
}
/**
* 运行任务
*
*@return mixed
*/
public function run()
{
// 这儿要重视，生成器的起始会reset，因此第1个值要用current获取
if ($this->beforeFirstYield) {
$this->beforeFirstYield = false;
return $this->coroutine->current();
} else {
// 咱们说过了，用send去调用一个生成器
$retval = $this->coroutine->send($this->sendValue);
$this->sendValue = null;
return$retval;
}
}
}2）Scheduler实现
接下来便是Scheduler这个重点核心部分，他装扮着调度员的角色。 /**
* Class Scheduler
*/
Class Scheduler
{
/**
* @varSplQueue
*/
protected $taskQueue;
/**
* @var int
*/
protected $tid = 0;
/**
* Scheduler constructor.
*/
public function __construct()
{
/* 原理便是守护了一个队列，
* 前面说过，从编程方向上看，协程的思想本质上便是掌控流的主动让出（yield）和恢复（resume）机制
* */
$this->taskQueue = newSplQueue();
}/**
* 增多一个任务
*
* @param Generator $task
* @return int
*/
public function addTask(Generator $task)
{
$tid =$this->tid;
$task = new Task($tid, $task);
$this->taskQueue->enqueue($task);
$this->tid++;
return $tid;
}
/**
* 把任务进入队列
*
*@param Task $task
*/
public function schedule(Task $task)
{
$this->taskQueue->enqueue($task);
}
/**
* 运行调度器
*/
public function run()
{
while (!$this->taskQueue->isEmpty()) {
// 任务出队
$task = $this->taskQueue->dequeue();
$res = $task->run(); // 运行任务直到 yield
if(!$task->isFinished()) {$this->schedule($task); // 任务倘若还没完全执行完毕，入队等下次执行
}
}
}
}
这般咱们基本就实现了一个协程调度器。
你能够运用下面的代码来测试： <?php
function task1() {
for($i =1; $i <= 10; ++$i) {
echo "This is task 1 iteration $i.\n";
yield; // 主动让出CPU的执行权
}
}
function task2() {
for ($i = 1; $i <= 5; ++$i) {
echo "This is task 2 iteration $i.\n";
yield; // 主动让出CPU的执行权
}
}
$scheduler = new Scheduler; // 实例化一个调度器
$scheduler->newTask(task1()); // 添加区别的闭包函数做为任务$scheduler->newTask(task2());
$scheduler->run();
关键说下在哪里能用得到PHP协程。 function task1() {
/* 这儿有一个远程任务，需要耗时10s，可能是一个远程设备抓取分析远程网址的任务，咱们只要提交最后去远程设备拿结果就行了 */remote_task_commit();// 此时候请求发出后，咱们不要在这儿等，主动让出CPU的执行权给task2运行，他不依赖这个结果
yield;
yield (remote_task_receive());
...
}
function task2() {
for ($i = 1; $i <= 5; ++$i) {echo "This is task 2 iteration $i.\n";
yield; // 主动让出CPU的执行权
}
}
这般就加强了程序的执行效率。
关于『系统调用』的实现，鸟哥已然讲得很明白，我这儿再也不说明。
3）协程堆栈
鸟哥文中还有一个协程堆栈的例子。
咱们上面说过了，倘若在函数中使用了yield，就不可当做函数运用。
因此你在一个协程函数中嵌套另一一个协程函数： <?php
function echoTimes($msg, $max) {
for ($i = 1; $i <= $max; ++$i) {
echo "$msg iteration $i\n";
yield;
}
}function task() {
echoTimes(foo, 10); // print foo ten times
echo "---\n";
echoTimes(bar, 5); // print bar five times
yield; // force it to be a coroutine
}
$scheduler = new Scheduler;
$scheduler->newTask(task());
$scheduler->run();
这儿的echoTimes是执行不了的！因此就需要协程堆栈。
不外不碍事，咱们改一改咱们刚才的代码。
把Task中的初始化办法改下，由于咱们在运行一个Task的时候，咱们要分析出他包括了那些子协程，而后将子协程用一个堆栈保留。（C语言学的好的朋友自然能理解这儿，不睬解的朋友我意见去认识下进程的内存模型是怎么处理函数调用） /**
* Task constructor.
*@param $taskId
* @param Generator $coroutine
*/
public function __construct($taskId, Generator $coroutine)
{
$this->taskId = $taskId;// $this->coroutine = $coroutine;
// 换成这个，实质Task->run的便是stackedCoroutine这个函数，不是$coroutine保留的闭包函数了
$this->coroutine = stackedCoroutine($coroutine);
}当Task->run()的时候，一个循环来分析： /**
* @param Generator $gen
*/
function stackedCoroutine(Generator $gen)
{
$stack = newSplStack;// 持续遍历这个传进来的生成器
for (; ;) {
// $gen能够理解为指向当前运行的协程闭包函数（生成器）
$value = $gen->current(); // 获取中断点，亦便是yield出来的值
if ($value instanceof Generator) {
// 倘若是亦是一个生成器，这便是子协程了，把当前运行的协程入栈保留
$stack->push($gen);
$gen = $value; // 把子协程函数给gen，继续执行，重视接下来便是执行子协程的流程了
continue;
}
// 咱们对子协程返回的结果做了封装，下面讲$isReturnValue = $value instanceof CoroutineReturnValue;// 子协程返回`$value`需要主协程帮忙处理
if (!$gen->valid() || $isReturnValue) {
if ($stack->isEmpty()) {
return;
}
// 倘若是gen已然执行完毕，或遇到子协程需要返回值给主协程去处理
$gen = $stack->pop(); //出栈，得到之前入栈保留的主协程
$gen->send($isReturnValue ? $value->getValue() : NULL); // 调用主协程处理子协程的输出值
continue;
}
$gen->send(yield $gen->key() => $value); // 继续执行子协程
}
}
而后咱们增多echoTime的结束标示： class CoroutineReturnValue {
protected $value;
public function __construct($value) {
$this->value = $value;
}
// 获取能把子协程的输出值给主协程，做为主协程的send参数
public function getValue() {
return $this->value;
}
}
function retval($value) {
return new CoroutineReturnValue($value);
}
而后修改echoTimes： function echoTimes($msg, $max) {
for ($i = 1; $i <= $max; ++$i) {
echo "$msg iteration $i\n";
yield;
}
yield retval(""); // 增多这个做为结束标示
}
Task变为： function task1()
{
yield echoTimes(bar, 5);
}
这般就实现了一个协程堆栈，此刻你能够举一反三了。
4）PHP7中yield from关键字
PHP7中增多了yield from，因此咱们不需要自己实现携程堆栈，真实太好了。
把Task的构造函数改回去： public function __construct($taskId, Generator $coroutine)
{
$this->taskId = $taskId;
$this->coroutine = $coroutine;// $this->coroutine = stackedCoroutine($coroutine); //不需要自己实现了，改回之前的
}
echoTimes函数： function echoTimes($msg, $max) {
for ($i = 1; $i <= $max; ++$i) {
echo "$msg iteration $i\n";
yield;
}
}
task1生成器： function task1()
{
yield from echoTimes(bar, 5);
}
function task1()
{
yield from echoTimes(bar, 5);
}
这般，容易调用子协程。
| 
发表于