PHP 協程實現過程詳解
實現 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"; }
輸出:
0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
看上去功能和 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 迭代器)
- 無法在一次呼叫獲取所需的所有元素時
- 要處理數量巨大的元素時(資料庫中要處理的結果集內容超過記憶體)
- …
生成器
雖然迭代器僅需繼承介面即可實現,但畢竟需要定義一整個類然後實現介面的所有方法,實在是不怎麼方便。
生成器則提供了一種更簡單的方式來實現簡單的物件迭代,相比定義類來實現
Iterator
介面的方式,效能開銷和複雜度大大降低。
生成器允許在 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 類的定義以及語法參考。
同時需要注意的是:
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()
方法的例子才能理解。但可以簡單的記住:
除了 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】詳解模組的實現過程
- PHP7下的協程實現PHP
- Python協程詳解Python
- PHP 協程PHP
- MapReduce過程詳解
- 【PHP-FPM】重啟過程原始碼詳解PHP原始碼
- HTTPS協議詳解(四):TLS/SSL握手過程HTTP協議TLS
- Python中協程(coroutine)詳解Python
- 詳解NTP網路時間協議工作過程協議
- Phxrpc協程庫實現RPC
- promise實現過程Promise
- Python非同步協程(asyncio詳解)Python非同步
- SSL/TLS 握手過程詳解TLS
- mongo 儲存過程詳解Go儲存過程
- 轉:DNS解析過程詳解DNS
- Redis複製過程詳解Redis
- RabbitMQ安裝過程詳解MQ
- 【elasticsearch】搜尋過程詳解Elasticsearch
- 常見下載方式之BT下載實現過程詳解
- 堆排序的Python實現(附詳細過程圖和講解)排序Python
- swoole 協程原始碼解讀 (協程的排程)原始碼
- Kotlin Coroutine(協程): 三、瞭解協程Kotlin
- Golang協程池(workpool)實現Golang
- python協程詳細解釋以及例子Python
- Unity 協程(Coroutine)原理與用法詳解Unity
- Spring AOP實現過程Spring
- RPC(遠端過程呼叫)詳解RPC
- SpringIOC初始化過程--詳解Spring
- 詳解Linux 程式編譯過程Linux編譯
- 理論+實驗 詳解Oracle安裝部署過程Oracle
- 跟羽夏去實現協程
- GoLang協程Goroutiney原理與GMP模型詳解Golang模型
- swoole 協程原始碼解讀 (協程的建立)原始碼
- PHP 多工協程處理PHP
- 手寫IOC實現過程
- 手寫AOP實現過程
- 換膚功能實現過程
- [轉]:xmake編譯配置過程詳解編譯
- Mybatis詳解(二) sqlsession的建立過程MyBatisSQLSession