이 글은 주로 참고할만한 가치가 있는 PHP의 멀티 태스킹 코루틴 처리에 대해 소개합니다. 이제 도움이 필요한 친구들이 참고할 수 있도록 공유하겠습니다.
자, 시작해 보세요!
이 기사에서 논의할 내용은 다음과 같습니다. 하지만 더 간단하고 친숙한 예부터 시작하겠습니다.
간단한 탐색으로 배열을 사용할 수 있습니다.
$array = ["foo", "bar", "baz"];
foreach ($array as $key => $value) {
print "item: " . $key . "|" . $value . "\n";
}
for ($i = 0; $i <p>이것은 일상적인 코딩에 의존하는 기본 구현입니다. 배열을 순회하면 각 요소의 키 이름과 키 값을 얻을 수 있습니다. </p><p>물론, 언제 배열을 사용할 수 있는지 알고 싶다면 말이죠. PHP는 편리한 내장 함수를 제공합니다: </p><pre class="brush:php;toolbar:false">print is_array($array) ? "yes" : "no"; // yes때때로 일부 데이터를 동일한 방식으로 탐색해야 하지만 이는 배열 유형이 아닙니다. 예를 들어 DOMDocument 클래스를 처리하는 경우:
$document = new DOMDocument();
$document->loadXML("<p></p>");
$elements = $document->getElementsByTagName("p");
print_r($elements); // DOMNodeList Object ( [length] => 1 )이것은 분명히 배열은 아니지만 length 속성이 있습니다. 배열처럼 탐색할 수 있나요? 다음과 같은 특수 인터페이스를 구현하는지 확인할 수 있습니다.
print ($elements instanceof Traversable) ? "yes" : "no"; // yes
이것은 정말 유용합니다. 통과할 수 없는 데이터를 반복할 때 오류가 발생하지 않습니다. 처리하기 전에 테스트만 하면 됩니다.
그러나 이것은 또 다른 질문을 제기할 것입니다. 사용자 정의 클래스에도 이 기능이 있도록 만들 수 있습니까? 대답은 그렇습니다! 첫 번째 구현은 다음과 같습니다.
class MyTraversable implements Traversable
{
// 在这里编码...
}이 클래스를 실행하면 오류 메시지가 표시됩니다.
PHP 치명적인 오류: MyTraversable 클래스는 Iterator 또는 IteratorAggregate
의 일부로 Traversable 인터페이스를 구현해야 합니다. Traversable을 직접 구현할 수는 없지만 두 번째 옵션인
class MyTraversable implements Iterator
{
// 在这里编码...
}이 인터페이스를 사용하려면 5 메소드를 구현해야 합니다. 반복자를 개선해 보겠습니다.
class MyTraversable implements Iterator
{
protected $data;
protected $index = 0;
public function __construct($data)
{
$this->data = $data;
}
public function current()
{
return $this->data[$this->index];
}
public function next()
{
return $this->data[$this->index++];
}
public function key()
{
return $this->index;
}
public function rewind()
{
$this->index = 0;
}
public function valid()
{
return $this->index data);
}
}여기에서 몇 가지 사항에 주의해야 합니다.
나중에 해당 요소를 가져올 수 있도록 생성자 메서드에서 전달된 $data 배열을 저장해야 합니다.
에는 current 또는 next 요소를 추적하기 위한 내부 인덱스(또는 포인터)도 필요합니다.
rewind()는 index 속성만 재설정하여 current() 및 next()가 제대로 작동하도록 합니다.
키 이름은 숫자 유형으로 제한되지 않습니다! 여기서는 예제를 단순하게 유지하기 위해 배열 인덱싱을 사용했습니다.
이 코드를 다음과 같이 실행할 수 있습니다.
$iterator = new MyIterator(["foo", "bar", "baz"]);
foreach ($iterator as $key => $value) {
print "item: " . $key . "|" . $value . "\n";
}작업이 너무 많아 보일 수도 있지만 foreach/for 기능을 배열처럼 사용할 수 있도록 깔끔하게 구현한 것입니다.
두 번째 인터페이스에서 발생한 Traversable 예외를 기억하시나요? Iterator 인터페이스를 구현하는 것보다 더 빠른 구현을 살펴보겠습니다.
class MyIteratorAggregate implements IteratorAggregate
{
protected $data;
public function __construct($data)
{
$this->data = $data;
}
public function getIterator()
{
return new ArrayIterator($this->data);
}
}여기서 속임수를 쓰고 있습니다. 완전한 Iterator를 구현하는 대신 ArrayIterator()를 통해 장식합니다. 그러나 이는 전체 Iterator를 구현하는 것에 비해 코드를 훨씬 단순화합니다.
형제 여러분, 걱정하지 마세요! 먼저 일부 코드를 비교해 보겠습니다. 먼저 생성기를 사용하지 않고 파일에서 데이터의 각 줄을 읽습니다.
$content = file_get_contents(__FILE__);
$lines = explode("\n", $content);
foreach ($lines as $i => $line) {
print $i . ". " . $line . "\n";
}이 코드는 파일 자체를 읽은 다음 줄 번호와 각 줄의 코드를 인쇄합니다. 그렇다면 발전기를 사용하는 것은 어떨까요!
function lines($file) {
$handle = fopen($file, 'r');
while (!feof($handle)) {
yield trim(fgets($handle));
}
fclose($handle);
}
foreach (lines(__FILE__) as $i => $line) {
print $i . ". " . $line . "\n";
}이게 더 복잡해 보인다는 걸 알아요. 나쁘지는 않지만 file_get_contents() 함수를 사용하지 않기 때문입니다. 생성기는 함수처럼 보이지만 yield 키워드를 얻을 때마다 실행을 중지합니다.
Generator는 반복자와 약간 유사합니다.
print_r(lines(__FILE__)); // Generator Object ( )
반복자는 아니지만 Generator입니다. 내부적으로 정의된 메소드는 무엇입니까?
print_r(get_class_methods(lines(__FILE__))); // Array // ( // [0] => rewind // [1] => valid // [2] => current // [3] => key // [4] => next // [5] => send // [6] => throw // [7] => __wakeup // )
큰 파일을 읽은 다음 memory_get_peak_usage()를 사용하면 파일 크기에 관계없이 생성기 코드가 고정된 양의 메모리를 사용한다는 것을 알 수 있습니다. 한 줄씩 진행됩니다. 대신 file_get_contents() 함수를 사용하여 전체 파일을 읽으면 더 많은 메모리를 사용하게 됩니다. 이런 일을 반복할 때 생성기가 우리에게 이점을 제공하는 곳이 바로 여기입니다!
데이터를 생성기로 보낼 수 있습니다. 아래 생성기를 살펴보세요.
<?php $generator = call_user_func(function() {
yield "foo";
});
print $generator->current() . "\n"; // foo注意这里我们如何在 call_user_func() 函数中封装生成器函数的？这里仅仅是一个简单的函数定义，然后立即调用它获取一个新的生成器实例...
我们已经见过 yield 的用法。我们可以通过扩展这个生成器来接收数据：
$generator = call_user_func(function() {
$input = (yield "foo");
print "inside: " . $input . "\n";
});
print $generator->current() . "\n";
$generator->send("bar");数据通过 yield 关键字传入和返回。首先，执行 current() 代码直到遇到 yield，返回 foo。send() 将输出传入到生成器打印输入的位置。你需要习惯这种用法。
由于我们需要同这些函数进行交互，可能希望将异常推送到生成器中。这样这些函数就可以自行处理异常。
看看下面这个示例：
$multiply = function($x, $y) {
yield $x * $y;
};
print $multiply(5, 6)->current(); // 30现在让我们将它封装到另一个函数中：
$calculate = function ($op, $x, $y) use ($multiply) {
if ($op === 'multiply') {
$generator = $multiply($x, $y);
return $generator->current();
}
};
print $calculate("multiply", 5, 6); // 30这里我们通过一个普通闭包将乘法生成器封装起来。现在让我们验证无效参数：
$calculate = function ($op, $x, $y) use ($multiply) {
if ($op === "multiply") {
$generator = $multiply($x, $y);
if (!is_numeric($x) || !is_numeric($y)) {
throw new InvalidArgumentException();
}
return $generator->current();
}
};
print $calculate('multiply', 5, 'foo'); // PHP Fatal error...如果我们希望能够通过生成器处理异常？我们怎样才能将异常传入生成器呢！
$multiply = function ($x, $y) {
try {
yield $x * $y;
} catch (InvalidArgumentException $exception) {
print "ERRORS!";
}
};
$calculate = function ($op, $x, $y) use ($multiply) {
if ($op === "multiply") {
$generator = $multiply($x, $y);
if (!is_numeric($x) || !is_numeric($y)) {
$generator->throw(new InvalidArgumentException());
}
return $generator->current();
}
};
print $calculate('multiply', 5, 'foo'); // PHP Fatal error...棒呆了！我们不仅可以像迭代器一样使用生成器。还可以通过它们发送数据并抛出异常。它们是可中断和可恢复的函数。有些语言把这些函数叫做……
我们可以使用协程（coroutines）来构建异步代码。让我们来创建一个简单的任务调度程序。首先我们需要一个 Task 类：
class Task
{
protected $generator;
public function __construct(Generator $generator)
{
$this->generator = $generator;
}
public function run()
{
$this->generator->next();
}
public function finished()
{
return !$this->generator->valid();
}
}Task 是普通生成器的装饰器。我们将生成器赋值给它的成员变量以供后续使用，然后实现一个简单的 run() 和 finished() 方法。run() 方法用于执行任务，finished() 方法用于让调度程序知道何时终止运行。
然后我们需要一个 Scheduler 类：
class Scheduler
{
protected $queue;
public function __construct()
{
$this->queue = new SplQueue();
}
public function enqueue(Task $task)
{
$this->queue->enqueue($task);
}
pulic function run()
{
while (!$this->queue->isEmpty()) {
$task = $this->queue->dequeue();
$task->run();
if (!$task->finished()) {
$this->queue->enqueue($task);
}
}
}
}Scheduler 用于维护一个待执行的任务队列。run() 会弹出队列中的所有任务并执行它，直到运行完整个队列任务。如果某个任务没有执行完毕，当这个任务本次运行完成后，我们将再次入列。
SplQueue 对于这个示例来讲再合适不过了。它是一种 FIFO（先进先出：fist in first out） 数据结构，能够确保每个任务都能够获取足够的处理时间。
我们可以像这样运行这段代码：
$scheduler = new Scheduler();
$task1 = new Task(call_user_func(function() {
for ($i = 0; $i enqueue($task1);
$scheduler->enqueue($task2);
$scheduler->run();运行时，我们将看到如下执行结果：
task 1: 0 task 1: 1 task 2: 0 task 2: 1 task 1: 2 task 2: 2 task 2: 3 task 2: 4 task 2: 5
这几乎就是我们想要的执行结果。不过有个问题发生在首次运行每个任务时，它们都执行了两次。我们可以对 Task 类稍作修改来修复这个问题：
class Task
{
protected $generator;
protected $run = false;
public function __construct(Generator $generator)
{
$this->generator = $generator;
}
public function run()
{
if ($this->run) {
$this->generator->next();
} else {
$this->generator->current();
}
$this->run = true;
}
public function finished()
{
return !$this->generator->valid();
}
}我们需要调整首次 run() 方法调用，从生成器当前有效的指针读取运行。后续调用可以从下一个指针读取运行...
有些人基于这个思路实现了一些超赞的类库。我们来看看其中的两个...
RecoilPHP 是一套基于协程的类库，它最令人印象深刻的是用于 ReactPHP 内核。可以将事件循环在 RecoilPHP 和 RecoilPHP 之间进行交换，而你的程序无需架构上的调整。
我们来看一下 ReactPHP 异步 DNS 解决方案：
function resolve($domain, $resolver) {
$resolver
->resolve($domain)
->then(function ($ip) use ($domain) {
print "domain: " . $domain . "\n";
print "ip: " . $ip . "\n";
}, function ($error) {
print $error . "\n";
})
}
function run()
{
$loop = React\EventLoop\Factory::create();
$factory = new React\Dns\Resolver\Factory();
$resolver = $factory->create("8.8.8.8", $loop);
resolve("silverstripe.org", $resolver);
resolve("wordpress.org", $resolver);
resolve("wardrobecms.com", $resolver);
resolve("pagekit.com", $resolver);
$loop->run();
}
run();resolve() 接收域名和 DNS 解析器，并使用 ReactPHP 执行标准的 DNS 查找。不用太过纠结与 resolve() 函数内部。重要的是这个函数不是生成器，而是一个函数！
run() 创建一个 ReactPHP 事件循环，DNS 解析器（这里是个工厂实例）解析若干域名。同样，这个也不是一个生成器。
想知道 RecoilPHP 到底有何不同？还希望掌握更多细节！
use Recoil\Recoil;
function resolve($domain, $resolver)
{
try {
$ip = (yield $resolver->resolve($domain));
print "domain: " . $domain . "\n";
print "ip: " . $ip . "\n";
} catch (Exception $exception) {
print $exception->getMessage() . "\n";
}
}
function run()
{
$loop = (yield Recoil::eventLoop());
$factory = new React\Dns\Resolver\Factory();
$resolver = $factory->create("8.8.8.8", $loop);
yield [
resolve("silverstripe.org", $resolver),
resolve("wordpress.org", $resolver),
resolve("wardrobecms.com", $resolver),
resolve("pagekit.com", $resolver),
];
}
Recoil::run("run");通过将它集成到 ReactPHP 来完成一些令人称奇的工作。每次运行 resolve() 时，RecoilPHP 会管理由 $resoler->resolve() 返回的 promise 对象，然后将数据发送给生成器。此时我们就像在编写同步代码一样。与我们在其他一步模型中使用回调代码不同，这里只有一个指令列表。
RecoilPHP 知道它应该管理一个有执行 run() 函数时返回的 yield 数组。RoceilPHP 还支持基于协程的数据库（PDO）和日志库。
IcicleIO 为了一全新的方案实现 ReactPHP 一样的目标，而仅仅使用协程功能。相比 ReactPHP 它仅包含极少的组件。但是，核心的异步流、服务器、Socket、事件循环特性一个不落。
让我们看一个 socket 服务器示例：
use Icicle\Coroutine\Coroutine;
use Icicle\Loop\Loop;
use Icicle\Socket\Client\ClientInterface;
use Icicle\Socket\Server\ServerInterface;
use Icicle\Socket\Server\ServerFactory;
$factory = new ServerFactory();
$coroutine = Coroutine::call(function (ServerInterface $server) {
$clients = new SplObjectStorage();
$handler = Coroutine::async(
function (ClientInterface $client) use (&$clients) {
$clients->attach($client);
$host = $client->getRemoteAddress();
$port = $client->getRemotePort();
$name = $host . ":" . $port;
try {
foreach ($clients as $stream) {
if ($client !== $stream) {
$stream->write($name . "connected.\n");
}
}
yield $client->write("Welcome " . $name . "!\n");
while ($client->isReadable()) {
$data = trim(yield $client->read());
if ("/exit" === $data) {
yield $client->end("Goodbye!\n");
} else {
$message = $name . ":" . $data . "\n";
foreach ($clients as $stream) {
if ($client !== $stream) {
$stream->write($message);
}
}
}
}
} catch (Exception $exception) {
$client->close($exception);
} finally {
$clients->detach($client);
foreach ($clients as $stream) {
$stream->write($name . "disconnected.\n");
}
}
}
);
while ($server->isOpen()) {
$handler(yield $server->accept());
}
}, $factory->create("127.0.0.1", 6000));
Loop::run();据我所知，这段代码所做的事情如下:
在 127.0.0.1 和 6000 端口创建一个服务器实例，然后将其传入外部生成器.
外部生成器运行，同时服务器等待新连接。当服务器接收一个连接它将其传入内部生成器。
内部生成器写入消息到 socket。当 socket 可读时运行。
每次 socket 向服务器发送消息时，内部生成器检测消息是否是退出标识。如果是，通知其他 socket。否则，其它 socket 发送这个相同的消息。
打开命令行终端输入 nc localhost 6000 查看执行结果！
该示例使用 SplObjectStorage 跟踪 socket 连接。这样我们就可以向所有 socket 发送消息。
这个话题可以包含很多内容。希望您能看到生成器是如何创建的，以及它们如何帮助编写迭代程序和异步代码。
如果你有问题，可以随时问我。
相关推荐：
위 내용은 PHP의 멀티태스킹 코루틴 처리 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
