Swoole協程與Go協程的區別，很詳細，很牛逼
阿新 • • 發佈：2020-06-24
- 程式是什麼？
程式就是應用程式的啟動例項。
例如：開啟一個軟體，就是開啟了一個程式。
程式擁有程式碼和開啟的檔案資源，資料資源，獨立的記憶體空間。
- 執行緒是什麼？
執行緒屬於程式，是程式的執行者。
一個程式至少包含一個主執行緒，也可以有更多的子執行緒。
執行緒有兩種排程策略，一是：分時排程，二是：搶佔式排程。
- 協程是什麼？
協程是輕量級執行緒,協程的建立、切換、掛起、銷燬全部為記憶體操作，消耗是非常低的。
協程是屬於執行緒，協程是線上程裡執行的。
協程的排程是使用者手動切換的，所以又叫使用者空間執行緒。
協程的排程策略是：協作式排程。
Swoole 協程
- Swoole 的協程客戶端必須在協程的上下文環境中使用。
// 第一種情況：Request 回撥本身是協程環境
$server->on('Request',function($request,$response) {
// 建立 Mysql 協程客戶端
$mysql = new Swoole\Coroutine\MySQL();
$mysql->connect([]);
$mysql->query();
});
// 第二種情況：WorkerStart 回撥不是協程環境
$server->on('WorkerStart',function() {
// 需要先宣告一個協程環境，才能使用協程客戶端
go(function - Swoole 的協程是基於單執行緒的,無法利用多核CPU，同一時間只有一個在排程。
// 啟動 4 個協程
$n = 4;
for ($i = 0; $i < $n; $i++) {
go(function () use ($i) {
// 模擬 IO 等待
Co::sleep(1);
echo - Swoole 協程使用示例及詳解
// 建立一個 Http 服務
$server = new Swoole\Http\Server('127.0.0.1',9501,SWOOLE_BASE);
// 呼叫 onRequest 事件回撥函式時，底層會呼叫 C 函式 coro_create 建立一個協程，
// 同時儲存這個時間點的 CPU 暫存器狀態和 ZendVM stack 資訊。
$server->on('Request',$response) {
// 建立一個 Mysql 的協程客戶端
$mysql = new Swoole\Coroutine\MySQL();
// 呼叫 mysql->connect 時發生 IO 操作，底層會呼叫 C 函式 coro_save 儲存當前協程的狀態，
// 包括 Zend VM 上下文以及協程描述的資訊，並呼叫 coro_yield 讓出程式控制權，當前的請求會掛起。
// 當協程讓出控制權之後，會繼續進入 EventLoop 處理其他事件，這時 Swoole 會繼續去處理其他客戶端發來的 Request。
$res = $mysql->connect([
'host' => '127.0.0.1','user' => 'root','password' => 'root','database' => 'test'
]);
// IO 事件完成後，MySQL 連線成功或失敗，底層呼叫 C 函式 coro_resume 恢復對應的協程，恢復 ZendVM 上下文，繼續向下執行 PHP 程式碼。
if ($res == false) {
$response->end("MySQL connect fail");
return;
}
// mysql->query 的執行過程和 mysql->connect 一致，也會進行一次協程切換排程
$ret = $mysql->query('show tables',2);
// 所有操作完成後，呼叫 end 方法返回結果，並銷燬此協程。
$response->end('swoole response is ok,result='.var_export($ret,true));
});
// 啟動服務
$server->start();複製程式碼Go 的協程 goroutine
goroutine 是輕量級的執行緒，Go 語言從語言層面就支援原生協程。
Go 協程與執行緒相比，開銷非常小。
Go 協程的堆疊開銷只用2KB，它可以根據程式的需要增大和縮小，
而執行緒必須指定堆疊的大小，並且堆疊的大小都是固定的。
goroutine 是通過 GPM 排程模型實現的。
M: 表示核心級執行緒，一個 M 就是一個執行緒，goroutine 跑在 M 之上的。
G: 表示一個 goroutine，它有自己的棧。
P: 全稱是 Processor，處理器。它主要用來執行 goroutine 的，同時它也維護了一個 goroutine 佇列。
Go 在 runtime、系統呼叫等多個方面對 goroutine 排程進行了封裝和處理，當遇到長時間執行或進行系統呼叫時，
會主動把當前協程的 CPU 轉讓出去，讓其他協程排程執行。
- Go 語言原生層面就支援協層，不需要宣告協程環境。
package main
import "fmt"
func main() {
// 直接通過 Go 關鍵字，就可以啟動一個協程。
go func() {
fmt.Println("Hello Go!")
}()
}複製程式碼- Go 協程是基於多執行緒的，可以利用多核 CPU，同一時間可能會有多個協程在執行。
package main
import (
"fmt"
"time"
)
func main() {
// 設定這個引數，可以模擬單執行緒與 Swoole 的協程做比較
// 如果這個引數設定成 1，則每次輸出的結果都一樣。
// runtime.GOMAXPROCS(1)
// 啟動 4 個協程
var i int64
for i = 0; i < 4; i++ {
go func(i int64) {
// 模擬 IO 等待
time.Sleep(1 * time.Second)
fmt.Printf("hello %d \n",i)
}(i)
}
fmt.Println("hello main")
// 等待其他的協程執行完，如果不等待的話，
// main 執行完退出後，其他的協程也會相繼退出。
time.Sleep(10 * time.Second)
}
// 第一次輸出的結果
$ go run test.go
hello main
hello 2
hello 1
hello 0
hello 3
// 第二次輸出的結果
$ go run test.go
hello main
hello 2
hello 0
hello 3
hello 1
// 依次類推，每次輸出的結果都不一樣複製程式碼- go 協程使用示例及詳解
package main
import (
"fmt"
"github.com/jinzhu/gorm"
"net/http"
"time"
)
import _ "github.com/go-sql-driver/mysql"
func main() {
dsn := fmt.Sprintf("%v:%v@(%v:%v)/%v?charset=utf8&parseTime=True&loc=Local","root","127.0.0.1","3306","fastadmin",)
db,err := gorm.Open("mysql",dsn)
if err != nil {
fmt.Printf("mysql connection failure,error: (%v)",err.Error())
return
}
db.DB().SetMaxIdleConns(10) // 設定連線池
db.DB().SetMaxOpenConns(100) // 設定與資料庫建立連線的最大數目
db.DB().SetConnMaxLifetime(time.Second * 7)
http.HandleFunc("/test",func(writer http.ResponseWriter,request *http.Request) {
// http Request 是在協程中處理的
// 在 Go 原始碼 src/net/http/server.go:2851 行處 `go c.serve(ctx)` 給每個請求啟動了一個協程
var name string
row := db.Table("fa_auth_rule").Where("id = ?",1).Select("name").Row()
err = row.Scan(&name)
if err != nil {
fmt.Printf("error: %v",err)
return
}
fmt.Printf("name: %v \n",name)
})
http.ListenAndServe("0.0.0.0:8001",nil)
}複製程式碼案例分析
背景：
在我們的積分策略服務系統中，使用到了 mongodb 儲存，但是 swoole 沒有提供 mongodb 協程客戶端。 那麼這種場景下，在連線及操作 Mongodb 時會發生同步阻塞，無法發生協程切換，導致整個程式都會阻塞。在這段時間內，程式將無法再處理新的請求，這使得系統的併發性大大降低。
使用同步的 mongodb 客戶端
$server->on('Request',$response) {
// swoole 沒有提供協程客戶端，那麼只能使用同步客戶端
// 這種情況下，程式阻塞，無法切換協程
$m = new MongoClient(); // 連線到mongodb
$db = $m->test; // 選擇一個資料庫
$collection = $db->runoob; // 選擇集合
// 更新檔案
$collection->update(array("title"=>"MongoDB"),array('$set'=>array("title"=>"Swoole")));
$cursor = $collection->find();
foreach ($cursor as $document) {
echo $document["title"] . "\n";
}
}}複製程式碼通過使用 Server->taskCo 來非同步化對 mongodb 的操作
$server->on('Task',function (swoole_server $serv,$task_id,$worker_id,$data) {
$m = new MongoClient(); // 連線到mongodb
$db = $m->test; // 選擇一個資料庫
$collection = $db->runoob; // 選擇集合
// 更新檔案
$collection->update(array("title"=>"MongoDB"),array('$set'=>array("title"=>"Swoole")));
$cursor = $collection->find();
foreach ($cursor as $document) {
$data = $document["title"];
}
return $data;
});
$server->on('Request',function ($request,$response) use ($server) {
// 通過 $server->taskCo() 把對 mongodb 的操作，投遞到非同步 task 中。
// 投遞到非同步 task 後，將發生協程切換，可以繼續處理其他的請求，提供併發能力。
$tasks[] = "hello world";
$result = $server->taskCo($tasks,0.5);
$response->end('Test End,Result: '.var_export($result,true));
});複製程式碼上面兩種使用方式就是 Swoole 中常用的方法了。
那麼我們在 Go 中怎麼處理這種同步的問題呢 ？
實際上在 Go 語言中就不用擔心這個問題了，如我們之前所說到的，
Go 在語言層面就已經支援協程了，只要是發生 IO 操作，網路請求都會發生協程切換。
這也就是 Go 語言天生以來就支援高併發的原因了。
package main
import (
"fmt"
"gopkg.in/mgo.v2"
"net/http"
)
func main() {
http.HandleFunc("/test",request *http.Request) {
session,err := mgo.Dial("127.0.0.1:27017")
if err != nil {
fmt.Printf("Error: %v \n",err)
return
}
session.SetMode(mgo.Monotonic,true)
c := session.DB("test").C("runoob")
fmt.Printf("Connect %v \n",c)
})
http.ListenAndServe("0.0.0.0:8001",nil)
}複製程式碼==並行：同一時刻，同一個 CPU 只能執行同一個任務，要同時執行多個任務，就需要有多個 CPU。==
==併發：CPU 切換時間任務非常快，就會感覺到有很多工在同時執行。==
協程 CPU 密集場景排程
我們上面說到都是基於 IO 密集場景的排程。
那麼如果是 CPU 密集型的場景，應該怎麼處理呢？
在 Swoole v4.3.2 版本中，已經支援了協程 CPU 密集場景的排程。
想要支援 CPU 密集排程，需要在編譯時增加編譯選項 --enable-scheduler-tick 開啟 tick 排程器。
其次還需要我們手動宣告 declare(tick=N) 語法功能來實現協程排程。
<?php
declare(ticks=1000);
$max_msec = 10;
Swoole\Coroutine::set([
'max_exec_msec' => $max_msec,]);
$s = microtime(1);
echo "start\n";
$flag = 1;
go(function () use (&$flag,$max_msec){
echo "coro 1 start to loop for $max_msec msec\n";
$i = 0;
while($flag) {
$i ++;
}
echo "coro 1 can exit\n";
});
$t = microtime(1);
$u = $t-$s;
echo "shedule use time ".round($u * 1000,5)." ms\n";
go(function () use (&$flag){
echo "coro 2 set flag = false\n";
$flag = false;
});
echo "end\n";
// 輸出結果
start
coro 1 start to loop for 10 msec
shedule use time 10.2849 ms
coro 2 set flag = false
end
coro 1 can exit複製程式碼Go 在 CPU 密集運算時，有可能導致協程無法搶佔 CPU 會一直掛起。
這時候就需要顯示的呼叫程式碼 runtime.Gosched() 掛起當前協程，讓出 CPU 給其他的協程。
package main
import (
"fmt"
"time"
)
func main() {
// 如果設定單執行緒，則第一個協程無法讓出時間片
// 第二個協程一直得不到時間片，阻塞等待。
// runtime.GOMAXPROCS(1)
flag := true
go func() {
fmt.Printf("coroutine one start \n")
i := 0
for flag {
i++
// 如果加了這行程式碼，協程可以讓時間片
// 這個因為 fmt.Printf 是行內函式，這是種特殊情況
// fmt.Printf("i: %d \n",i)
}
fmt.Printf("coroutine one exit \n")
}()
go func() {
fmt.Printf("coroutine two start \n")
flag = false
fmt.Printf("coroutine two exit \n")
}()
time.Sleep(5 * time.Second)
fmt.Printf("end \n")
}
// 輸出結果
coroutine one start
coroutine two start
coroutine two exit
coroutine one exit
end複製程式碼注：==time.sleep() 模擬 IO 操作，for i++ 模擬 CPU 密集運算。==
總結
- 協程是輕量級的執行緒，開銷很小。
- Swoole 的協程客戶端需要在協程的上下文環境中使用。
- 在 Swoole v4.3.2 版本之後，已經支援協程 CPU 密集場景排程。
- Go 語言層面就已經完全支援協程了。
更多swoole的知識分享如果喜歡我的文章，想與一群資深開發者一起交流學習的話，獲取更歡迎加入我的學習交流群677079770一起學習成長