PHP 協程實現過程詳解

newton.sh發表於2017-04-29

實現 PHP 協程需要了解的基本內容。

多程式/執行緒

最早的伺服器端程式都是通過多程式、多執行緒來解決併發IO的問題。程式模型出現的最早，從Unix 系統誕生就開始有了程式的概念。最早的伺服器端程式一般都是 Accept 一個客戶端連線就建立一個程式，然後子程式進入迴圈同步阻塞地與客戶端連線進行互動，收發處理資料。

多執行緒模式出現要晚一些，執行緒與程式相比更輕量，而且執行緒之間共享記憶體堆疊，所以不同的執行緒之間互動非常容易實現。比如實現一個聊天室，客戶端連線之間可以互動，聊天室中的玩家可以任意的其他人發訊息。用多執行緒模式實現非常簡單，執行緒中可以直接向某一個客戶端連線傳送資料。而多程式模式就要用到管道、訊息佇列、共享記憶體等等統稱程式間通訊（IPC）複雜的技術才能實現。

最簡單的多程式服務端模型

$serv = stream_socket_server("tcp://0.0.0.0:8000", $errno, $errstr) 
or die("Create server failed");
while(1) {
	$conn = stream_socket_accept($serv);
	if (pcntl_fork() == 0) {
		$request = fread($conn);
		// do something
		// $response = "hello world";
		fwrite($response);
		fclose($conn);
		exit(0);
	}
}

多程式/執行緒模型的流程是：

建立一個 socket，繫結伺服器埠（bind），監聽埠（listen），在 PHP 中用 stream_socket_server 一個函式就能完成上面 3 個步驟，當然也可以使用更底層的sockets 擴充套件分別實現。

進入 while 迴圈，阻塞在 accept 操作上，等待客戶端連線進入。此時程式會進入睡眠狀態，直到有新的客戶端發起 connect 到伺服器，作業系統會喚醒此程式。accept 函式返回客戶端連線的 socket 主程式在多程式模型下通過 fork（php: pcntl_fork）建立子程式，多執行緒模型下使用 pthread_create（php: new Thread）建立子執行緒。

下文如無特殊宣告將使用程式同時表示程式/執行緒。

子程式建立成功後進入 while 迴圈，阻塞在 recv（php:fread）呼叫上，等待客戶端向伺服器傳送資料。收到資料後伺服器程式進行處理然後使用 send（php: fwrite）向客戶端傳送響應。長連線的服務會持續與客戶端互動，而短連線服務一般收到響應就會 close。

當客戶端連線關閉時，子程式退出並銷燬所有資源，主程式會回收掉此子程式。

這種模式最大的問題是，程式建立和銷燬的開銷很大。所以上面的模式沒辦法應用於非常繁忙的伺服器程式。對應的改進版解決了此問題，這就是經典的 Leader-Follower 模型。

$serv = stream_socket_server("tcp://0.0.0.0:8000", $errno, $errstr) 
or die("Create server failed");
for($i = 0; $i < 32; $i++) {
    if (pcntl_fork() == 0) {
        while(1) {
            $conn = stream_socket_accept($serv);
            if ($conn == false) continue;
            // do something
            $request = fread($conn);
            // $response = "hello world";
            fwrite($response);
            fclose($conn);
        }
        exit(0);
    }
}

它的特點是程式啟動後就會建立 N 個程式。每個子程式進入 Accept，等待新的連線進入。當客戶端連線到伺服器時，其中一個子程式會被喚醒，開始處理客戶端請求，並且不再接受新的 TCP 連線。當此連線關閉時，子程式會釋放，重新進入 Accept，參與處理新的連線。

這個模型的優勢是完全可以複用程式，沒有額外消耗，效能非常好。很多常見的伺服器程式都是基於此模型的，比如 Apache、PHP-FPM。

多程式模型也有一些缺點。

這種模型嚴重依賴程式的數量解決併發問題，一個客戶端連線就需要佔用一個程式，工作程式的數量有多少，併發處理能力就有多少。作業系統可以建立的程式數量是有限的。

啟動大量程式會帶來額外的程式排程消耗。數百個程式時可能程式上下文切換排程消耗佔 CPU 不到 1% 可以忽略不計，如果啟動數千甚至數萬個程式，消耗就會直線上升。排程消耗可能佔到 CPU 的百分之幾十甚至 100%。

並行和併發

談到多程式以及類似同時執行多個任務的模型，就不得不先談談並行和併發。

併發（Concurrency）

是指能處理多個同時活動的能力，併發事件之間不一定要同一時刻發生。

並行（Parallesim）

是指同時刻發生的兩個併發事件，具有併發的含義，但併發不一定並行。

區別

『併發』指的是程式的結構，『並行』指的是程式執行時的狀態
『並行』一定是併發的，『並行』是『併發』設計的一種
單執行緒永遠無法達到『並行』狀態

正確的併發設計的標準是：

使多個操作可以在重疊的時間段內進行。
two tasks can start, run, and complete in overlapping time periods

參考：

迭代器 & 生成器

在瞭解 PHP 協程前，還有 迭代器 和 生成器 這兩個概念需要先認識一下。

迭代器

PHP5 開始內建了 Iterator 即迭代器介面，所以如果你定義了一個類，並實現了Iterator 介面，那麼你的這個類物件就是 ZEND_ITER_OBJECT 即可迭代的，否則就是 ZEND_ITER_PLAIN_OBJECT。

對於 ZEND_ITER_PLAIN_OBJECT 的類，foreach 會獲取該物件的預設屬性陣列，然後對該陣列進行迭代。

而對於 ZEND_ITER_OBJECT 的類物件，則會通過呼叫物件實現的 Iterator 介面相關函式來進行迭代。

任何實現了 Iterator 介面的類都是可迭代的，即都可以用 foreach 語句來遍歷。

Iterator 介面

interface Iterator extends Traversable
{
	// 獲取當前內部標量指向的元素的資料
    public mixed current()
	// 獲取當前標量
    public scalar key()
	// 移動到下一個標量
    public void next()
	// 重置標量
    public void rewind()
	// 檢查當前標量是否有效
    public boolean valid()
}

常規實現 range 函式

PHP 自帶的 range 函式原型：

range — 根據範圍建立陣列，包含指定的元素

array range (mixed $start , mixed $end [, number $step = 1 ])

建立一個包含指定範圍單元的陣列。

在不使用迭代器的情況要實現一個和 PHP 自帶的 range 函式類似的功能，可能會這麼寫：

function range ($start, $end, $step = 1)
{
    $ret = [];

    for ($i = $start; $i <= $end; $i += $step) {
        $ret[] = $i;
    }

    return $ret;
}

需要將生成的所有元素放在記憶體陣列中，如果需要生成一個非常大的集合，則會佔用巨大的記憶體。

迭代器實現 xrange 函式

來看看迭代實現的 range，我們叫做 xrange，他實現了 Iterator 介面必須的 5 個方法：

class Xrange implements Iterator
{
    protected $start;
    protected $limit;
    protected $step;
    protected $current;
    public function __construct($start, $limit, $step = 1)
    {
        $this->start = $start;
        $this->limit = $limit;
        $this->step  = $step;
    }
    public function rewind()
    {
        $this->current = $this->start;
    }
    public function next()
    {
        $this->current += $this->step;
    }
    public function current()
    {
        return $this->current;
    }
    public function key()
    {
        return $this->current + 1;
    }
    public function valid()
    {
        return $this->current <= $this->limit;
    }
}

使用時程式碼如下：

foreach (new Xrange(0, 9) as $key => $val) {
    echo $key, ' ', $val, "\n";
}

輸出：

看上去功能和 range() 函式所做的一致，不同點在於迭代的是一個 物件(Object) 而不是陣列：

var_dump(new Xrange(0, 9));

輸出：

object(Xrange)#1 (4) {
  ["start":protected]=>
  int(0)
  ["limit":protected]=>
  int(9)
  ["step":protected]=>
  int(1)
  ["current":protected]=>
  NULL
}

另外，記憶體的佔用情況也完全不同：

// range
$startMemory = memory_get_usage();
$arr = range(0, 500000);
echo 'range(): ', memory_get_usage() - $startMemory, " bytes\n";
unset($arr);
// xrange
$startMemory = memory_get_usage();
$arr = new Xrange(0, 500000);
echo 'xrange(): ', memory_get_usage() - $startMemory, " bytes\n";

輸出：

xrange(): 624 bytes
range(): 72194784 bytes

range() 函式在執行後佔用了 50W 個元素記憶體空間，而 xrange 物件在整個迭代過程中只佔用一個物件的記憶體。

Yii2 Query

在喜聞樂見的各種 PHP 框架裡有不少生成器的例項，比如 Yii2 中用來構建 SQL 語句的 \yii\db\Query類：

$query = (new \yii\db\Query)->from('user');
// yii\db\BatchQueryResult
foreach ($query->batch() as $users) {
    // 每次迴圈得到多條 user 記錄
}

來看一下 batch() 做了什麼：

/**
* Starts a batch query.
*
* A batch query supports fetching data in batches, which can keep the memory usage under a limit.
* This method will return a [[BatchQueryResult]] object which implements the [[\Iterator]] interface
* and can be traversed to retrieve the data in batches.
*
* For example,
*
*
* $query = (new Query)->from('user');
* foreach ($query->batch() as $rows) {
*     // $rows is an array of 10 or fewer rows from user table
* }
*
*
* @param integer $batchSize the number of records to be fetched in each batch.
* @param Connection $db the database connection. If not set, the "db" application component will be used.
* @return BatchQueryResult the batch query result. It implements the [[\Iterator]] interface
* and can be traversed to retrieve the data in batches.
*/
public function batch($batchSize = 100, $db = null)
{
   return Yii::createObject([
       'class' => BatchQueryResult::className(),
       'query' => $this,
       'batchSize' => $batchSize,
       'db' => $db,
       'each' => false,
   ]);
}

實際上返回了一個 BatchQueryResult 類，類的原始碼實現了 Iterator 介面 5 個關鍵方法：

class BatchQueryResult extends Object implements \Iterator
{
    public $db;
    public $query;
    public $batchSize = 100;
    public $each = false;
    private $_dataReader;
    private $_batch;
    private $_value;
    private $_key;
    /**
     * Destructor.
     */
    public function __destruct()
    {
        // make sure cursor is closed
        $this->reset();
    }
    /**
     * Resets the batch query.
     * This method will clean up the existing batch query so that a new batch query can be performed.
     */
    public function reset()
    {
        if ($this->_dataReader !== null) {
            $this->_dataReader->close();
        }
        $this->_dataReader = null;
        $this->_batch = null;
        $this->_value = null;
        $this->_key = null;
    }
    /**
     * Resets the iterator to the initial state.
     * This method is required by the interface [[\Iterator]].
     */
    public function rewind()
    {
        $this->reset();
        $this->next();
    }
    /**
     * Moves the internal pointer to the next dataset.
     * This method is required by the interface [[\Iterator]].
     */
    public function next()
    {
        if ($this->_batch === null || !$this->each || $this->each && next($this->_batch) === false) {
            $this->_batch = $this->fetchData();
            reset($this->_batch);
        }
        if ($this->each) {
            $this->_value = current($this->_batch);
            if ($this->query->indexBy !== null) {
                $this->_key = key($this->_batch);
            } elseif (key($this->_batch) !== null) {
                $this->_key++;
            } else {
                $this->_key = null;
            }
        } else {
            $this->_value = $this->_batch;
            $this->_key = $this->_key === null ? 0 : $this->_key + 1;
        }
    }
    /**
     * Fetches the next batch of data.
     * @return array the data fetched
     */
    protected function fetchData()
    {
        // ...
    }
    /**
     * Returns the index of the current dataset.
     * This method is required by the interface [[\Iterator]].
     * @return integer the index of the current row.
     */
    public function key()
    {
        return $this->_key;
    }
    /**
     * Returns the current dataset.
     * This method is required by the interface [[\Iterator]].
     * @return mixed the current dataset.
     */
    public function current()
    {
        return $this->_value;
    }
    /**
     * Returns whether there is a valid dataset at the current position.
     * This method is required by the interface [[\Iterator]].
     * @return boolean whether there is a valid dataset at the current position.
     */
    public function valid()
    {
        return !empty($this->_batch);
    }
}

以迭代器的方式實現了類似分頁取的效果，同時避免了一次性取出所有資料佔用太多的記憶體空間。

迭代器使用場景

使用返回迭代器的包或庫時（如 PHP5 中的 SPL 迭代器）
無法在一次呼叫獲取所需的所有元素時
要處理數量巨大的元素時（資料庫中要處理的結果集內容超過記憶體）
…

生成器

需要 PHP 5 >= 5.5.0 或 PHP 7

雖然迭代器僅需繼承介面即可實現，但畢竟需要定義一整個類然後實現介面的所有方法，實在是不怎麼方便。

生成器則提供了一種更簡單的方式來實現簡單的物件迭代，相比定義類來實現 Iterator 介面的方式，效能開銷和複雜度大大降低。

PHP Manual

生成器允許在 foreach 程式碼塊中迭代一組資料而不需要建立任何陣列。一個生成器函式，就像一個普通的有返回值的自定義函式類似，但普通函式只返回一次, 而生成器可以根據需要通過 yield 關鍵字返回多次，以便連續生成需要迭代返回的值。

一個最簡單的例子就是使用生成器來重新實現 xrange() 函式。效果和上面我們用迭代器實現的差不多，但實現起來要簡單的多。

生成器實現 `xrange` 函式

function xrange($start, $limit, $step = 1) {
    for ($i = 0; $i < $limit; $i += $step) { 
        yield $i + 1 => $i;
    }
}
foreach (xrange(0, 9) as $key => $val) {
    printf("%d %d \n", $key, $val);
}
// 輸出
// 1 0
// 2 1
// 3 2
// 4 3
// 5 4
// 6 5
// 7 6
// 8 7
// 9 8

實際上生成器生成的正是一個迭代器物件例項，該迭代器物件繼承了 Iterator 介面，同時也包含了生成器物件自有的介面，具體可以參考 Generator 類的定義以及語法參考。

同時需要注意的是：

一個生成器不可以返回值，這樣做會產生一個編譯錯誤。然而 return 空是一個有效的語法並且它將會終止生成器繼續執行。

yield 關鍵字

需要注意的是 yield 關鍵字，這是生成器的關鍵。通過上面的例子可以看出，yield 會將當前產生的值傳遞給 foreach，換句話說，foreach 每一次迭代過程都會從 yield 處取一個值，直到整個遍歷過程不再能執行到 yield 時遍歷結束，此時生成器函式簡單的退出，而呼叫生成器的上層程式碼還可以繼續執行，就像一個陣列已經被遍歷完了。

yield 最簡單的呼叫形式看起來像一個 return 申明，不同的是 yield 暫停當前過程的執行並返回值，而 return 是中斷當前過程並返回值。暫停當前過程，意味著將處理權轉交由上一級繼續進行，直到上一級再次呼叫被暫停的過程，該過程又會從上一次暫停的位置繼續執行。這像是什麼呢？如果之前已經在鳥哥的文章中粗略看過，應該知道這很像作業系統的程式排程，多個程式在一個 CPU 核心上執行，在系統排程下每一個程式執行一段指令就被暫停，切換到下一個程式，這樣外部使用者看起來就像是同時在執行多個任務。

但僅僅如此還不夠，yield 除了可以返回值以外，還能接收值，也就是可以在兩個層級間實現雙向通訊。

來看看如何傳遞一個值給 yield：

function printer()
{
    while (true) {
        printf("receive: %s\n", yield);
    }
}
$printer = printer();
$printer->send('hello');
$printer->send('world');
// 輸出
receive: hello
receive: world

根據 PHP 官方文件的描述可以知道 Generator 物件除了實現 Iterator 介面中的必要方法以外，還有一個 send 方法，這個方法就是向 yield 語句處傳遞一個值，同時從 yield 語句處繼續執行，直至再次遇到 yield 後控制權回到外部。

既然 yield 可以在其位置中斷並返回或者接收一個值，那能不能同時進行接收和返回呢？當然，這也是實現協程的根本。對上述程式碼做出修改：

function printer()
{
    $i = 0;
    while (true) {
        printf("receive: %s\n", (yield ++$i));
    }
}
$printer = printer();
printf("%d\n", $printer->current());
$printer->send('hello');
printf("%d\n", $printer->current());
$printer->send('world');
printf("%d\n", $printer->current());
// 輸出
1
receive: hello
2
receive: world
3

這是另一個例子：

function gen() {
    $ret = (yield 'yield1');
    var_dump($ret);
    $ret = (yield 'yield2');
    var_dump($ret);
}

$gen = gen();
var_dump($gen->current());    // string(6) "yield1"
var_dump($gen->send('ret1')); // string(4) "ret1"   (第一個 var_dump)
                              // string(6) "yield2" (繼續執行到第二個 yield，吐出了返回值)
var_dump($gen->send('ret2')); // string(4) "ret2"   (第二個 var_dump)
                              // NULL (var_dump 之後沒有其他語句，所以這次 ->send() 的返回值為 null)

current 方法是迭代器 Iterator 介面必要的方法，foreach 語句每一次迭代都會通過其獲取當前值，而後呼叫迭代器的 next 方法。在上述例子裡則是手動呼叫了 current 方法獲取值。

上述例子已經足以表示 yield 能夠作為實現雙向通訊的工具，也就是具備了後續實現協程的基本條件。

上面的例子如果第一次接觸並稍加思考，不免會疑惑為什麼一個 yield 既是語句又是表示式，而且這兩種情況還同時存在：

對於所有在生成器函式中出現的 yield，首先它都是語句，而跟在 yield 後面的任何表示式的值將作為呼叫生成器函式的返回值，如果 yield 後面沒有任何表示式（變數、常量都是表示式），那麼它會返回 NULL，這一點和 return 語句一致。
yield 也是表示式，它的值就是 send 函式傳過來的值（相當於一個特殊變數，只不過賦值是通過 send 函式進行的）。只要呼叫send方法，並且生成器物件的迭代並未終結，那麼當前位置的 yield 就會得到 send 方法傳遞過來的值，這和生成器函式有沒有把這個值賦值給某個變數沒有任何關係。

這個地方可能需要仔細品味上面兩個 send() 方法的例子才能理解。但可以簡單的記住：

任何時候 yield 關鍵詞即是語句：可以為生成器函式返回值；也是表示式：可以接收生成器物件發過來的值。

除了 send() 方法，還有一種控制生成器執行的方法是 next() 函式：

Next()，恢復生成器函式的執行直到下一個 yield
Send()，向生成器傳入一個值，恢復執行直到下一個 yield

協程

對於單核處理器，多程式實現多工的原理是讓作業系統給一個任務每次分配一定的 CPU 時間片，然後中斷、讓下一個任務執行一定的時間片接著再中斷並繼續執行下一個，如此反覆。由於切換執行任務的速度非常快，給外部使用者的感受就是多個任務的執行是同時進行的。

多程式的排程是由作業系統來實現的，程式自身不能控制自己何時被排程，也就是說：

程式的排程是由外層排程器搶佔式實現的

而協程要求當前正在執行的任務自動把控制權回傳給排程器，這樣就可以繼續執行其他任務。這與『搶佔式』的多工正好相反, 搶佔多工的排程器可以強制中斷正在執行的任務, 不管它自己有沒有意願。『協作式多工』在 Windows 的早期版本 (windows95) 和 Mac OS 中有使用, 不過它們後來都切換到『搶佔式多工』了。理由相當明確：如果僅依靠程式自動交出控制的話，那麼一些惡意程式將會很容易佔用全部 CPU 時間而不與其他任務共享。

協程的排程是由協程自身主動讓出控制權到外層排程器實現的

回到剛才生成器實現 xrange 函式的例子，整個執行過程的交替可以用下圖來表示：

協程可以理解為純使用者態的執行緒，通過協作而不是搶佔來進行任務切換。相對於程式或者執行緒，協程所有的操作都可以在使用者態而非作業系統核心態完成，建立和切換的消耗非常低。

簡單的說 Coroutine（協程） 就是提供一種方法來中斷當前任務的執行，儲存當前的區域性變數，下次再過來又可以恢復當前區域性變數繼續執行。

我們可以把大任務拆分成多個小任務輪流執行，如果有某個小任務在等待系統 IO，就跳過它，執行下一個小任務，這樣往復排程，實現了 IO 操作和 CPU 計算的並行執行，總體上就提升了任務的執行效率，這也便是協程的意義。

PHP 協程和 yield

PHP 從 5.5 開始支援生成器及 yield 關鍵字，而 PHP 協程則由 yield 來實現。

要理解協程，首先要理解：程式碼是程式碼，函式是函式。函式包裹的程式碼賦予了這段程式碼附加的意義：不管是否顯式的指明返回值，當函式內的程式碼塊執行完後都會返回到呼叫層。而當呼叫層呼叫某個函式的時候，必須等這個函式返回，當前函式才能繼續執行，這就構成了後進先出，也就是 Stack。

而協程包裹的程式碼，不是函式，不完全遵守函式的附加意義，協程執行到某個點，協會協程會 yield返回一個值然後掛起，而不是 return 一個值然後結束，當再次呼叫協程的時候，會在上次 yield 的點繼續執行。

所以協程違背了通常作業系統和 x86 的 CPU 認定的程式碼執行方式，也就是 Stack 的這種執行方式，需要執行環境（比如 php，python 的 yield 和 golang 的 goroutine）自己排程，來實現任務的中斷和恢復，具體到 PHP，就是靠 yield 來實現。

堆疊式呼叫 和 協程呼叫的對比：

結合之前的例子，可以總結一下 yield 能做的就是：

實現不同任務間的主動讓位、讓行，把控制權交回給任務排程器。
通過 send() 實現不同任務間的雙向通訊，也就可以實現任務和排程器之間的通訊。

yield 就是 PHP 實現協程的方式。

協程多工排程

下面是雄文 Cooperative multitasking using coroutines (in PHP!) 裡一個簡單但完整的例子，來展示如何具體的在 PHP 裡實現協程任務的排程。

首先是一個任務類：

Task

class Task
{
    // 任務 ID
    protected $taskId;
    // 協程物件
    protected $coroutine;
    // send() 值
    protected $sendVal = null;
    // 是否首次 yield
    protected $beforeFirstYield = true;
    public function __construct($taskId, Generator $coroutine) {
        $this->taskId = $taskId;
        $this->coroutine = $coroutine;
    }

    public function getTaskId() {
        return $this->taskId;
    }
    public function setSendValue($sendVal) {
        $this->sendVal = $sendVal;
    }
    public function run() {
        // 如之前提到的在send之前, 當迭代器被建立後第一次 yield 之前，一個 renwind() 方法會被隱式呼叫
        // 所以實際上發生的應該類似:
        // $this->coroutine->rewind();
        // $this->coroutine->send();

        // 這樣 renwind 的執行將會導致第一個 yield 被執行, 並且忽略了他的返回值.
        // 真正當我們呼叫 yield 的時候, 我們得到的是第二個yield的值，導致第一個yield的值被忽略。
        // 所以這個加上一個是否第一次 yield 的判斷來避免這個問題
        if ($this->beforeFirstYield) {
            $this->beforeFirstYield = false;
            return $this->coroutine->current();
        } else {
            $retval = $this->coroutine->send($this->sendVal);
            $this->sendVal = null;
            return $retval;
        }
    }
    public function isFinished() {
        return !$this->coroutine->valid();
    }
}

接下來是排程器，比 foreach 是要複雜一點，但好歹也能算個正兒八經的 Scheduler :)

Scheduler

class Scheduler
{
    protected $maxTaskId = 0;
    protected $taskMap = []; // taskId => task
    protected $taskQueue;

    public function __construct() {
        $this->taskQueue = new SplQueue();
    }

    // （使用下一個空閒的任務id）建立一個新任務,然後把這個任務放入任務map陣列裡. 接著它通過把任務放入任務佇列裡來實現對任務的排程. 接著run()方法掃描任務佇列, 執行任務.如果一個任務結束了, 那麼它將從佇列裡刪除, 否則它將在佇列的末尾再次被排程。
    public function newTask(Generator $coroutine) {
        $tid = ++$this->maxTaskId;
        $task = new Task($tid, $coroutine);
        $this->taskMap[$tid] = $task;
        $this->schedule($task);
        return $tid;
    }

    public function schedule(Task $task) {
    	// 任務入隊
        $this->queue->enqueue($task);
    }

    public function run() {
        while (!$this->queue->isEmpty()) {
        	// 任務出隊
            $task = $this->queue->dequeue();
            $task->run();

            if ($task->isFinished()) {
                unset($this->taskMap[$task->getTaskId()]);
            } else {
                $this->schedule($task);
            }
        }
    }
}

佇列可以使每個任務獲得同等的 CPU 使用時間，

Demo

function task1() {
    for ($i = 1; $i <= 10; ++$i) {
        echo "This is task 1 iteration $i.\n";
        yield;
    }
}

function task2() {
    for ($i = 1; $i <= 5; ++$i) {
        echo "This is task 2 iteration $i.\n";
        yield;
    }
}

$scheduler = new Scheduler;

$scheduler->newTask(task1());
$scheduler->newTask(task2());

$scheduler->run();

輸出：

This is task 1 iteration 1.
This is task 2 iteration 1.
This is task 1 iteration 2.
This is task 2 iteration 2.
This is task 1 iteration 3.
This is task 2 iteration 3.
This is task 1 iteration 4.
This is task 2 iteration 4.
This is task 1 iteration 5.
This is task 2 iteration 5.
This is task 1 iteration 6.
This is task 1 iteration 7.
This is task 1 iteration 8.
This is task 1 iteration 9.
This is task 1 iteration 10.

結果正是我們期待的，最初的 5 次迭代，兩個任務是交替進行的，而在第二個任務結束後，只有第一個任務繼續執行到結束。

協程非阻塞 IO

若想真正的發揮出協程的作用，那一定是在一些涉及到阻塞 IO 的場景，我們都知道 Web 伺服器最耗時的部分通常都是 socket 讀取資料等操作上，如果程式對每個請求都掛起的等待 IO 操作，那處理效率就太低了，接下來我們看個支援非阻塞 IO 的 Scheduler：

<?php
class Scheduler
{
    protected $maxTaskId = 0;
    protected $tasks = []; // taskId => task
    protected $queue;
    // resourceID => [socket, tasks]
    protected $waitingForRead = [];
    protected $waitingForWrite = [];

    public function __construct() {
        // SPL 佇列
        $this->queue = new SplQueue();
    }

    public function newTask(Generator $coroutine) {
        $tid = ++$this->maxTaskId;
        $task = new Task($tid, $coroutine);
        $this->tasks[$tid] = $task;
        $this->schedule($task);
        return $tid;
    }

    public function schedule(Task $task) {
    	// 任務入隊
        $this->queue->enqueue($task);
    }

    public function run() {
        while (!$this->queue->isEmpty()) {
        	// 任務出隊
            $task = $this->queue->dequeue();
            $task->run();

            if ($task->isFinished()) {
                unset($this->tasks[$task->getTaskId()]);
            } else {
                $this->schedule($task);
            }
        }
    }
    public function waitForRead($socket, Task $task)
    {
        if (isset($this->waitingForRead[(int)$socket])) {
            $this->waitingForRead[(int)$socket][1][] = $task;
        } else {
            $this->waitingForRead[(int)$socket] = [$socket, [$task]];
        }
    }
    public function waitForWrite($socket, Task $task)
    {
        if (isset($this->waitingForWrite[(int)$socket])) {
            $this->waitingForWrite[(int)$socket][1][] = $task;
        } else {
            $this->waitingForWrite[(int)$socket] = [$socket, [$task]];
        }
    }
    /**
     * @param $timeout 0 represent
     */
    protected function ioPoll($timeout)
    {
        $rSocks = [];
        foreach ($this->waitingForRead as list($socket)) {
            $rSocks[] = $socket;
        }
        $wSocks = [];
        foreach ($this->waitingForWrite as list($socket)) {
            $wSocks[] = $socket;
        }
        $eSocks = [];
        // $timeout 為 0 時, stream_select 為立即返回，為 null 時則會阻塞的等，見 http://php.net/manual/zh/function.stream-select.php
        if (!@stream_select($rSocks, $wSocks, $eSocks, $timeout)) {
            return;
        }
        foreach ($rSocks as $socket) {
            list(, $tasks) = $this->waitingForRead[(int)$socket];
            unset($this->waitingForRead[(int)$socket]);
            foreach ($tasks as $task) {
                $this->schedule($task);
            }
        }
        foreach ($wSocks as $socket) {
            list(, $tasks) = $this->waitingForWrite[(int)$socket];
            unset($this->waitingForWrite[(int)$socket]);
            foreach ($tasks as $task) {
                $this->schedule($task);
            }
        }
    }
    /**
     * 檢查佇列是否為空，若為空則掛起的執行 stream_select，否則檢查完 IO 狀態立即返回，詳見 ioPoll()
     * 作為任務加入佇列後，由於 while true，會被一直重複的加入任務佇列，實現每次任務前檢查 IO 狀態
     * @return Generator object for newTask
     *
     */
    protected function ioPollTask()
    {
        while (true) {
            if ($this->taskQueue->isEmpty()) {
                $this->ioPoll(null);
            } else {
                $this->ioPoll(0);
            }
            yield;
        }
    }
    /**
     * $scheduler = new Scheduler;
     * $scheduler->newTask(Web Server Generator);
     * $scheduler->withIoPoll()->run();
     *
     * 新建 Web Server 任務後先執行 withIoPoll() 將 ioPollTask() 作為任務入隊
     * 
     * @return $this
     */
    public function withIoPoll()
    {
        $this->newTask($this->ioPollTask());
        return $this;
    }
}

這個版本的 Scheduler 里加入一個永不退出的任務，並且通過 stream_select 支援的特性來實現快速的來回檢查各個任務的 IO 狀態，只有 IO 完成的任務才會繼續執行，而 IO 還未完成的任務則會跳過，完整的程式碼和例子可以戳這裡。

也就是說任務交替執行的過程中，一旦遇到需要 IO 的部分，排程器就會把 CPU 時間分配給不需要 IO 的任務，等到當前任務遇到 IO 或者之前的任務 IO 結束才再次排程 CPU 時間，以此實現 CPU 和 IO 並行來提升執行效率，類似下圖：

單任務改造

如果想將一個單程式任務改造成併發執行，我們可以選擇改造成多程式或者協程：

多程式，不改變任務執行的整體過程，在一個時間段內同時執行多個相同的程式碼段，排程權在 CPU，如果一個任務能獨佔一個 CPU 則可以實現並行。
協程，把原有任務拆分成多個小任務，原有任務的執行流程被改變，排程權在程式自己，如果有 IO 並且可以實現非同步，則可以實現並行。

多程式改造

協程改造

協程（Coroutines）和 Go 協程（Goroutines）

PHP 的協程或者其他語言中，比如 Python、Lua 等都有協程的概念，和 Go 協程有些相似，不過有兩點不同：

Go 協程意味著並行（或者可以以並行的方式部署，可以用 runtime.GOMAXPROCS() 指定可同時使用的 CPU 個數），協程一般來說只是併發。
Go 協程通過通道 channel 來通訊；協程通過 yield 讓出和恢復操作來通訊。

Go 協程比普通協程更強大，也很容易從協程的邏輯複用到 Go 協程，而且在 Go 的開發中也使用的極為普遍，有興趣的話可以瞭解一下作為對比。

結束

個人感覺 PHP 的協程在實際使用中想要徒手實現和應用並不方便而且場景有限，但瞭解其概念及實現原理對更好的理解併發不無裨益。

如果想更多的瞭解協程的實際應用場景不妨試試已經大名鼎鼎的 Swoole，其對多種協議的 client 做了底層的協程封裝，幾乎可以做到以同步程式設計的寫法實現協程非同步 IO 的效果。

參考

【Node】詳解模組的實現過程
2019-03-08
PHP7下的協程實現
2019-02-16
PHP
Python協程詳解
2019-09-23
Python
PHP 協程
2018-11-13
PHP
MapReduce過程詳解
2019-04-29
【PHP-FPM】重啟過程原始碼詳解
2019-07-17
PHP原始碼
HTTPS協議詳解(四)：TLS/SSL握手過程
2018-03-13
HTTP協議TLS
Python中協程（coroutine）詳解
2024-04-09
Python
詳解NTP網路時間協議工作過程
2020-06-25
協議
Phxrpc協程庫實現
2018-05-06
RPC
promise實現過程
2018-05-19
Promise
Python非同步協程（asyncio詳解）
2022-11-29
Python非同步
SSL/TLS 握手過程詳解
2019-03-04
TLS
mongo 儲存過程詳解
2018-12-15
Go儲存過程
轉：DNS解析過程詳解
2018-11-27
DNS
Redis複製過程詳解
2024-07-08
Redis
RabbitMQ安裝過程詳解
2021-09-09
MQ
【elasticsearch】搜尋過程詳解
2022-03-19
Elasticsearch
常見下載方式之BT下載實現過程詳解
2018-11-28
堆排序的Python實現(附詳細過程圖和講解)
2019-02-18
排序Python
swoole 協程原始碼解讀 (協程的排程)
2019-09-10
原始碼
Kotlin Coroutine(協程): 三、瞭解協程
2021-07-14
Kotlin
Golang協程池（workpool）實現
2020-07-03
Golang
python協程詳細解釋以及例子
2023-03-29
Python
Unity 協程(Coroutine)原理與用法詳解
2021-04-29
Unity
Spring AOP實現過程
2024-03-26
Spring
RPC（遠端過程呼叫）詳解
2024-04-27
RPC
SpringIOC初始化過程--詳解
2019-05-09
Spring
詳解Linux 程式編譯過程
2022-10-16
Linux編譯
理論+實驗詳解Oracle安裝部署過程
2020-10-22
Oracle
跟羽夏去實現協程
2024-05-04
GoLang協程Goroutiney原理與GMP模型詳解
2024-11-09
Golang模型
swoole 協程原始碼解讀 (協程的建立)
2019-09-09
原始碼
PHP 多工協程處理
2018-07-17
PHP
手寫IOC實現過程
2020-08-08
手寫AOP實現過程
2020-08-12
換膚功能實現過程
2020-12-29
[轉]：xmake編譯配置過程詳解
2019-02-16
編譯
Mybatis詳解(二) sqlsession的建立過程
2020-06-12
MyBatisSQLSession