协程
概念
Hyperf 是运行于 Swoole 4 的协程之上的，这也是 Hyperf 能提供高性能的其中一个很大的因素。
PHP-FPM 的运作模式
在聊协程是什么之前，我们先聊聊传统 PHP-FPM 架构的运作模式，PHP-FPM 是一个多进程的 FastCGI 管理程序，是绝大多数 PHP 应用所使用的运行模式。假设我们使用 Nginx 提供 HTTP 服务（Apache 同理），所有客户端发起的请求最先抵达的都是 Nginx，然后 Nginx 通过 FastCGI 协议将请求转发给 PHP-FPM 处理，PHP-FPM 的 Worker 进程 会抢占式的获得 CGI 请求进行处理，这个处理指的就是，等待 PHP 脚本的解析，等待业务处理的结果返回，完成后回收子进程，这整个的过程是阻塞等待的，也就意味着 PHP-FPM 的进程数有多少能处理的请求也就是多少，假设 PHP-FPM 有 200 个 Worker 进程，一个请求将耗费 1 秒的时间，那么简单的来说整个服务器理论上最多可以处理的请求也就是 200 个，QPS 即为 200/s，在高并发的场景下，这样的性能往往是不够的，尽管可以利用 Nginx 作为负载均衡配合多台 PHP-FPM 服务器来提供服务，但由于 PHP-FPM 的阻塞等待的工作模型，一个请求会占用至少一个 MySQL 连接，多节点高并发下会产生大量的 MySQL 连接，而 MySQL 的最大连接数默认值为 100，尽管可以修改，但显而易见该模式没法很好的应对高并发的场景。
异步非阻塞系统
在高并发的场景下，异步非阻塞就显得优势明显了，直观的优点表现就是 Worker 进程 不再同步阻塞的去处理一个请求，而是可以同时处理多个请求，无需 I/O 等待，并发能力极强，可以同时发起或维护大量的请求。那么最直观的缺点大家可能也都知道，就是永无止境的回调，业务逻辑必须在对应的回调函数内实现，如果业务逻辑存在多次的 I/O 请求，则会存在很多层的回调函数，下面示例一段 Swoole 1.x 下的异步回调型的伪代码片段。
$db = new swoole_mysql();
$config = array(
‘host’ => ‘127.0.0.1’,
‘port’ => 3306,
‘user’ => ‘test’,
‘password’ => ‘test’,
‘database’ => ‘test’,
);
d
b
−
>
c
o
n
n
e
c
t
(
db->connect(
db−>connect(config, function ($db, $r) {
// 从 users 表中查询一条数据
$sql = ‘select * from users where id = 1’;
d
b
−
>
q
u
e
r
y
(
db->query(
db−>query(sql, function(swoole_mysql $db, KaTeX parse error: Expected '}', got 'EOF' at end of input: … { if (r !== false) {
// 查询成功后修改一条数据
$updateSql = ‘update users set name=“new name” where id = 1’;
d
b
−
>
q
u
e
r
y
(
db->query(
db−>query(updateSql, function (swoole_mysql $db, $r) {
$rows =
d
b
−
>
a
f
f
e
c
t
e
d
r
o
w
s
;
i
f
(
db->affected_rows; if (
db−>affectedrows;if(r === true) {
return $this->response->end(‘更新成功’);
}
});
}
$db->close();
});
});
Copy to clipboardErrorCopied
注意 MySQL 等异步模块已在4.3.0中移除，并转移到了swoole_async。
从上面的代码片段可以看出，每一个操作几乎就需要一个回调函数，在复杂的业务场景中回调的层次感和代码结构绝对会让你崩溃，其实不难看出这样的写法有点类似 JavaScript 上的异步方法的写法，而 JavaScript 也为此提供了不少的解决方案（当然方案是源于其它编程语言），如 Promise，yield + generator, async/await，Promise 则是对回调的一种封装方式，而 yield + generator 和 async/await 则需要在代码上显性的增加一些代码语法标记，这些相对比回调函数来说，不妨都是一些非常不错的解决方案，但是你需要另花时间来理解它的实现机制和语法。
Swoole 协程也是对异步回调的一种解决方案，在 PHP 语言下，Swoole 协程与 yield + generator 都属于协程的解决方案，协程的解决方案可以使代码以近乎于同步代码的书写方式来书写异步代码，显性的区别则是 yield + generator 的协程机制下，每一处 I/O 操作的调用代码都需要在前面加上 yield 语法实现协程切换，每一层调用都需要加上，否则会出现意料之外的错误，而 Swoole 协程的解决方案对比于此就高明多了，在遇到 I/O 时底层自动的进行隐式协程切换，无需添加任何的额外语法，无需在代码前加上 yield，协程切换的过程无声无息，极大的减轻了维护异步系统的心智负担。
协程是什么？
我们已经知道了协程可以很好的解决异步非阻塞系统的开发问题，那么协程本身到底是什么呢？从定义上来说，协程是一种轻量级的线程，由用户代码来调度和管理，而不是由操作系统内核来进行调度，也就是在用户态进行。可以直接的理解为就是一个非标准的线程实现，但什么时候切换由用户自己来实现，而不是由操作系统分配 CPU 时间决定。具体来说，Swoole 的每个 Worker 进程 会存在一个协程调度器来调度协程，协程切换的时机就是遇到 I/O 操作或代码显性切换时，进程内以单线程的形式运行协程，也就意味着一个进程内同一时间只会有一个协程在运行且切换时机明确，也就无需处理像多线程编程下的各种同步锁的问题。
单个协程内的代码运行仍是串行的，放在一个 HTTP 协程服务上来理解就是每一个请求是一个协程，举个例子，假设为请求 A 创建了 协程 A，为 请求 B 创建了 协程 B，那么在处理 协程 A 的时候代码跑到了查询 MySQL 的语句上，这个时候 协程 A 则会触发协程切换，协程 A 就继续等待 I/O 设备返回结果，那么此时就会切换到 协程 B，开始处理 协程 B 的逻辑，当又遇到了一个 I/O 操作便又触发协程切换，再回过来从 协程 A 刚才切走的地方继续执行，如此反复，遇到 I/O 操作就切换到另一个协程去继续执行而非一直阻塞等待。
这里可以发现一个问题就是，协程 A 的 MySQL 查询操作必须得是一个异步非阻塞的操作，否则会由于阻塞导致协程调度器没法切换到另一个协程继续执行，这个也是要在协程编程下需要规避的问题之一。
协程与普通线程有哪些区别？
都说协程是一个轻量级的线程，协程和线程都适用于多任务的场景下，从这个角度上来说，协程与线程很相似，都有自己的上下文，可以共享全局变量，但不同之处在于，在同一时间可以有多个线程处于运行状态，但对于 Swoole 协程来说只能有一个，其它的协程都会处于暂停的状态。此外，普通线程是抢占式的，哪个线程能得到资源由操作系统决定，而协程是协作式的，执行权由用户态自行分配。
创建协程
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\Utils\Coroutine;
/**
* @AutoController()
*/
class CoController{
public function test(){
//创建协程得代码块
Coroutine::create(function(){
sleep(1);
var_dump(1);
});
}
}
创建协程go 短名
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\Utils\Coroutine;
/**
* @AutoController()
*/
class CoController{
public function test(){
//创建协程得代码块 短名创建协程
go(function(){
sleep(1);
var_dump(1);
});
}
}
创建协程co 短名 hyperf实现
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\Utils\Coroutine;
/**
* @AutoController()
*/
class CoController{
public function test(){
//创建协程得代码块 短名创建协程 co 推荐co来创建协程
co(function(){
sleep(1);
var_dump(1);
});
}
}
未使用协程前请求一共花销4秒+
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\HttpServer\Contract\RequestInterface;
use Hyperf\Di\Annotation\Inject;
/**
* @AutoController()
*/
class CoController{
/**
* @Inject
* @var \Hyperf\Guzzle\ClientFactory
* hyperf/guzzle 组件基于 Guzzle 进行协程处理，通过 Swoole HTTP 客户端作为协程驱动替换到 Guzzle 内，以达到 HTTP 客户端的协程化
*/
private $clientFactory;
public function sleep(RequestInterface $reques){
$seconds = $reques -> input('seconds', 1);
sleep($seconds);
return $seconds;
}
public function test(){
//一共花了4秒+
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
return 1;
}
}
使用co建立协程查看运行过程 花销时间2秒
执行过程
int(1)
int(2)
int(3)
int(6)
int(7)
int(8)
int(11)
int(4)
int(12)
int(5)
int(9)
int(13)
int(10)
通过运行过程可以看到
先进入协程 当遇到阻塞I/O操作的话，会切换协程到下一个代码块， 当又遇到阻塞I/O的时候又进入下一个代码块，当Channel获取结束后会跳到当时切换到的代码块往后执行push，之后跳出之后执行push后的代码
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\HttpServer\Contract\RequestInterface;
use Hyperf\Di\Annotation\Inject;
use Swoole\Coroutine\Channel;
/**
* @AutoController()
*/
class CoController{
/**
* @Inject
* @var \Hyperf\Guzzle\ClientFactory
* hyperf/guzzle 组件基于 Guzzle 进行协程处理，通过 Swoole HTTP 客户端作为协程驱动替换到 Guzzle 内，以达到 HTTP 客户端的协程化
*/
private $clientFactory;
public function sleep(RequestInterface $reques){
$seconds = $reques -> input('seconds', 1);
sleep($seconds);
return $seconds;
}
public function test(){
$channel = new Channel();
var_dump(1);
co(function() use($channel) {
var_dump(2);
$client = $this->clientFactory->create();
var_dump(3);
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
var_dump(4);
$channel->push('123');
var_dump(5);
});
var_dump(6);
co(function() use($channel){
var_dump(7);
$client = $this->clientFactory->create();
var_dump(8);
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
var_dump(9);
$channel->push('321');
var_dump(10);
});
var_dump(11);
$result[] = $channel->pop();
var_dump(12);
$result[] = $channel->pop();
var_dump(13);
return $result;
}
}
waitgroup协程使用
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\HttpServer\Contract\RequestInterface;
use Hyperf\Di\Annotation\Inject;
use Hyperf\Utils\WaitGroup;
/**
* @AutoController()
*/
class CoController{
/**
* @Inject
* @var \Hyperf\Guzzle\ClientFactory
* hyperf/guzzle 组件基于 Guzzle 进行协程处理，通过 Swoole HTTP 客户端作为协程驱动替换到 Guzzle 内，以达到 HTTP 客户端的协程化
*/
private $clientFactory;
public function sleep(RequestInterface $reques){
$seconds = $reques -> input('seconds', 1);
sleep($seconds);
return $seconds;
}
public function test(){
//使用的场景是主协程需要等待子协程完毕之后再往下跑
$wg = new WaitGroup();
$wg->add(2); # 填几就说明有几个协程需要等待
$result = []; //传入是使用& 引用传值
co(function() use($wg, &$result) {
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
$result[] = 123;
$wg->done(); #代表协程执行完毕， 会给协程计数器减1
});
co(function() use($wg, &$result){
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
$result[] = 321;
$wg->done();
});
$wg->wait(); #等待协程计数器变成0的时候协程就完成了
return $result;
}
}
parallel助手协程使用 Parallel是基于waitgroup实现的一个助手类
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\HttpServer\Contract\RequestInterface;
use Hyperf\Di\Annotation\Inject;
use Hyperf\Utils\Parallel;
/**
* @AutoController()
*/
class CoController{
/**
* @Inject
* @var \Hyperf\Guzzle\ClientFactory
* hyperf/guzzle 组件基于 Guzzle 进行协程处理，通过 Swoole HTTP 客户端作为协程驱动替换到 Guzzle 内，以达到 HTTP 客户端的协程化
*/
private $clientFactory;
public function sleep(RequestInterface $reques){
$seconds = $reques -> input('seconds', 1);
sleep($seconds);
return $seconds;
}
public function test(){
//Parallel是基于waitgroup实现的一个助手类
$paraller = new Parallel();
$paraller -> add(function(){
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
return 123;
});
$paraller -> add(function(){
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
return 789;
});
// 可以后面加key （foo， bar） 如果加key返回的就是key -> value的形式
// $paraller -> add(function(){
// $client = $this->clientFactory->create();
// $client->get('127.0.0.1:9501/co/sleep?seconds=2');
// return 789;
// }, 'bar');
$result = $paraller -> wait();
return $result;
}
}
使用Parallel全局函数更简便的实现协程
<?php
namespace App\Controller;
use Hyperf\HttpServer\Annotation\AutoController;
use Hyperf\HttpServer\Contract\RequestInterface;
use Hyperf\Di\Annotation\Inject;
use Hyperf\Utils\Parallel;
/**
* @AutoController()
*/
class CoController{
/**
* @Inject
* @var \Hyperf\Guzzle\ClientFactory
* hyperf/guzzle 组件基于 Guzzle 进行协程处理，通过 Swoole HTTP 客户端作为协程驱动替换到 Guzzle 内，以达到 HTTP 客户端的协程化
*/
private $clientFactory;
public function sleep(RequestInterface $reques){
$seconds = $reques -> input('seconds', 1);
sleep($seconds);
return $seconds;
}
public function test(){
//使用Parallel全局函数来更简便的实现协程
$result = Parallel([
function(){
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
return 123;
},
function(){
$client = $this->clientFactory->create();
$client->get('127.0.0.1:9501/co/sleep?seconds=2');
return 888;
}
]);
return $result;
}
}
简单介绍hyperf的协程使用方法， 更多的内容应该熟读文档
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
