关于PHP协程与阻塞的思考

进程、线程、协程

关于进程、线程、协程，有非常详细和丰富的博客或者学习资源，我不在此做赘述，我大致在此介绍一下这几个东西。

1. 进程拥有自己独立的堆和栈，既不共享堆，亦不共享栈，进程由操作系统调度。
2. 线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，线程亦由操作系统调度(标准线程是的)。
3. 协程和线程一样共享堆，不共享栈，协程由程序员在协程的代码里显示调度。

PHP中的协程实现基础 yield

yield的根本实现是生成器类，而迭代器类是迭代器接口的实现：

1. Generator implements Iterator { 
2.     public mixed current ( void ) // 返回当前产生的值 
3.     public mixed key ( void ) // 返回当前产生的键 
4.     public void next ( void ) // 生成器继续执行 
5.     public void rewind ( void ) // 重置迭代器，如果迭代已经开始了，这里会抛出一个异常。 
6.                                              // renwind的执行将会导致第一个yield被执行, 并且忽略了他的返回值. 
7.     public mixed send ( mixed $value ) // 向生成器中传入一个值，并且当做 yield 表达式的结果，然后继续执行生成器。如果当这个方法被调用时，生成器    
8.                                             // 不在 yield 表达式，那么在传入值之前，它会先运行到第一个 yield 表达式。 
9.     public void throw ( Exception $exception ) // 向生成器中抛入一个异常 
10.     public bool valid ( void ) // 检查迭代器是否被关闭 
11.     public void __wakeup ( void ) // 序列化回调，抛出一个异常以表示生成器不能被序列化。 
12. } 

以上解析可以参考PHP官方文档。

http://php.net/manual/zh/clas...

以及鸟哥翻译的这篇详细文档：

http://www.laruence.com/2015/...

我就以他实现的协程多任务调度为基础做一下例子说明并说一下关于我在阻塞方面所做的一些思考。

自定义简单定时执行任务示例：

(此例子必须依赖于以上鸟哥实现的协程调度代码)

1. class timer { 
2.     private $start = 0; // 定时开始时间 
3.     private $timer; // 间隔的时间差，单位秒 
4.     private $value = 0; // 产生的结果值 
5.     private $callback; // 异步回调 
6.     private $isEnd = false; // 当前定时器任务是否结束 
7.     public function __construct($timer,callable $callback) 
8.     { 
9.         $this->start = time(); 
10.         $this->timer = $timer; 
11.         $this->callback = $callback; 
12.     } 
13.     public function run() { 
14.         if($this->valid()) { 
15.             $callback = $this->callback; 
16.             $callback($this->value ++,$this); 
17.             $this->start = time(); 
18.         } 
19.     } 
20.     /** 
21.      * 定时执行检查 
22.      */ 
23.     public function valid() { 
24.         $end = time(); 
25.         if($end - $this->start >= $this->timer) { 
26.             return true; 
27.         } else { 
28.             return false; 
29.         } 
30.     } 
31.     public function setEnd($isEnd) { 
32.         $this->isEnd = $isEnd; 
33.     } 
34.     public function getEnd() { 
35.         return $this->isEnd; 
36.     } 
37. } 
38.  
39. /** 
40.  * 模拟阻塞的协程1 
41.  * 
42.  */ 
43. function taskObject1() { 
44.     $timer = new timer(1,function($value,timer $timer) { 
45.         if($value >= 5) { 
46.             $timer->setEnd(true); 
47.         } 
48.         echo '<br>'.'A '.$value; 
49.     }); 
50.     $tid = (yield getTaskId()); 
51.     while (true) { 
52.         if($timer->getEnd() == true) { 
53.             break; 
54.         } 
55.         yield $timer->run(); 
56.     } 
57. } 
58. /** 
59.  * 模拟阻塞的协程2 
60.  * 
61.  */ 
62. function taskObject2() { 
63.     $timer = new timer(2,function($value,timer $timer) { 
64.         if($value >= 3) { 
65.             $timer->setEnd(true); 
66.         } 
67.         echo '<br>'.'B '.$value; 
68.     }); 
69.     $tid = (yield getTaskId()); 
70.     while (true) { 
71.         if($timer->getEnd() == true) { 
72.             break; 
73.         } 
74.         yield $timer->run(); 
75.     } 
76. } 
77. $scheduler = new Scheduler; 
78. $scheduler->newTask(taskObject1()); 
79. $scheduler->newTask(taskObject2()); 
80. $scheduler->run(); 

以上实现的是：

1. 产生两个任务，并行执行，并且给每个任务在执行的时候模拟几秒钟的阻塞;
2. 让协程切换的时候能顺利切换，其中的任务阻塞不相互影响;

思考：

我为什么要做以上这件事情呢?因为我发现协程实现虽然很强大也很有意思，能让多任务并行，但是我在其中一个任务里调用系统函数 sleep() 的时候,阻塞任务会阻止协程切换，其实从协程的实现原理上来书也是这么回事。

那么，我也就想模拟协程阻塞，但是不产生阻塞看是否可行。PHP本身只提供了生成器为协程调用提供了支撑，如果不依赖扩展，没有提供多线程的程序实现方式，没有java那么强大，可以开子线程进行实现。

我印象中java的子线程是独立执行且不会相互阻塞的，所以我在想，PHP既然可以实现类似于多线程这样的机制，那么能不能实现调用过程中非阻塞呢?

经过这样一个实现和思考，一开始是陷入了一个误区的，是由于PHP原生函数 sleep() 阻塞造成的思维误区，那就是认为要想真正实现非阻塞或者说实现异步的话，是必须依赖于语言底层的。

后来，我想明白了一个道理，既然某个方法或者函数在执行过程中，会产生阻塞，那么把当前这个方法换成自定义的，做成非阻塞(相对于整个协程调度来说)不就行了吗?比如上面的定时执行我自己实现了一个。

而另一方面，协程调度本身的目的也是为了把任务执行过程切成尽量小片，从而快速切换执行，达到并行的目的。从这方面来看，协程应该也算是一种程序设计思想。

以下是一个程序切成尽量小片执行的例子：

1. // 一个简单的例子 
2. <?php 
3. function xrange($start, $end, $step = 1) { 
4.     for ($i = $start; $i <= $end; $i += $step) { 
5.         yield $i; 
6.     } 
7. } 
8.   
9. foreach (xrange(1, 1000000) as $num) { 
10.     echo $num, "\n"; 
11. } 

这个例子是把原本用 range 生成一个很大的整型数组的方式切换为分片执行，也就是说在遍历的时候再去取到指定的值，从代码上来看，内存消耗相对于之前来说就非常小了。

作者：kumfo

来源：51CTO