Detailed explanation of the implementation method of coroutine under PHP7

<?php
class MyIterator implements Iterator
{
 private $var = array();
 public function __construct($array)
 {
  if (is_array($array)) {
   $this->var = $array;
  }
 }
 public function rewind() {
  echo "rewinding\n";
  reset($this->var);
 }
 public function current() {
  $var = current($this->var);
  echo "current: $var\n";
  return $var;
 }
 public function key() {
  $var = key($this->var);
  echo "key: $var\n";
  return $var;
 }
 public function next() {
  $var = next($this->var);
  echo "next: $var\n";
  return $var;
 }
 public function valid() {
  $var = $this->current() !== false;
  echo "valid: {$var}\n";
  return $var;
 }
}
$values = array(1,2,3);
$it = new MyIterator($values);
foreach ($it as $a => $b) {
 print "$a: $b\n";
}

<?php
function xrange($start, $end, $step = 1) {
 for ($i = $start; $i <= $end; $i += $step) {
  yield $i;
 }
}
foreach (xrange(1, 1000000) as $num) {
 echo $num, "\n";
}

/**
  * Task task class
  */
class Task
{
 protected $taskId;
 protected $coroutine;
 protected $beforeFirstYield = true;
 protected $sendValue;

 /**
  * Task constructor.
  * @param $taskId
  * @param Generator $coroutine
  */
 public function __construct($taskId, Generator $coroutine)
 {
  $this->taskId = $taskId;
  $this->coroutine = $coroutine;
 }
 /**
   * Get the current Task ID
   *
   * @return mixed
   */
 public function getTaskId()
 {
  return $this->taskId;
 }
 /**
   * Determine whether the Task has been executed
   *
   * @return bool
   */
 public function isFinished()
 {
  return !$this->coroutine->valid();
 }
 /**
   * Set the value to be passed to the coroutine next time, such as $id = (yield $xxxx), this value will give $id
   *
   * @param $value
   */
 public function setSendValue($value)
 {
  $this->sendValue = $value;
 }
 /**
   * Run tasks
   *
   * @return mixed
   */
 public function run()
 {
  // Note here that the generator starts to reset, so the first value must be obtained using current  if ($this->beforeFirstYield) {
   $this->beforeFirstYield = false;
   return $this->coroutine->current();
  } else {
   // We said, use send to call a generator   $retval = $this->coroutine->send($this->sendValue);
   $this->sendValue = null;
   return $retval;
  }
 }
}

/**
 * Class Scheduler
 */
Class Scheduler
{
 /**
  * @var SplQueue
  */
 protected $taskQueue;
 /**
  * @var int
  */
 protected $tid = 0;

 /**
  * Scheduler constructor.
  */
 public function __construct()
 {
  /* The principle is to maintain a queue.
    * As mentioned earlier, from a programming perspective, the idea of ​​coroutines is essentially the active yield and recovery mechanism of control flows.
    * */
  $this->taskQueue = new SplQueue();
 }
 /**
   * Add a task
   *
   * @param Generator $task
   * @return int
   */
 public function addTask(Generator $task)
 {
  $tid = $this->tid;
  $task = new Task($tid, $task);
  $this->taskQueue->enqueue($task);
  $this->tid++;
  return $tid;
 }
 /**
   * Put the task into the queue
   *
   * @param Task $task
   */
 public function schedule(Task $task)
 {
  $this->taskQueue->enqueue($task);
 }
 /**
   * Run the scheduler
   */
 public function run()
 {
  while (!$this->taskQueue->isEmpty()) {
   // Mission dequeue   $task = $this->taskQueue->dequeue();
   $res = $task->run(); // Run the task until yield
   if (!$task->isFinished()) {
    $this->schedule($task); // If the task has not been fully executed, join the team and wait for the next execution   }
  }
 }
}

<?php
function task1() {
 for ($i = 1; $i <= 10; ++$i) {
  echo "This is task 1 iteration $i.\n";
  yield; // Actively give up the CPU's execution rights }
}
function task2() {
 for ($i = 1; $i <= 5; ++$i) {
  echo "This is task 2 iteration $i.\n";
  yield; // Actively give up the CPU's execution rights }
}
$scheduler = new Scheduler; // Instantiate a scheduler$scheduler->newTask(task1()); // Add different closure functions as tasks$scheduler->newTask(task2());
$scheduler->run();

function task1() {
  /* There is a remote task here, which takes 10 seconds. It may be a remote machine to crawl and analyze remote URLs. We just need to submit the results at the remote machine at the end */
  remote_task_commit();
  // After the request is issued, we should not wait here. We should actively give up the CPU's execution rights to task2 to run. It does not rely on this result  yield;
  yield (remote_task_receive());
  ...
} 
function task2() {
 for ($i = 1; $i <= 5; ++$i) {
  echo "This is task 2 iteration $i.\n";
  yield; // Actively give up the CPU's execution rights }
}

<?php
function echoTimes($msg, $max) {
 for ($i = 1; $i <= $max; ++$i) {
  echo "$msg iteration $i\n";
  yield;
 }
}
function task() {
 echoTimes('foo', 10); // print foo ten times
 echo "---\n";
 echoTimes('bar', 5); // print bar five times
 yield; // force it to be a coroutine
}
$scheduler = new Scheduler;
$scheduler->newTask(task());
$scheduler->run();

 /**
  * Task constructor.
  * @param $taskId
  * @param Generator $coroutine
  */
 public function __construct($taskId, Generator $coroutine)
 {
  $this->taskId = $taskId;
  // $this->coroutine = $coroutine;
  // If you change to this, the actual Task->run is the stackedCoroutine function, not the closure function saved by $coroutine  $this->coroutine = stackedCoroutine($coroutine); 
 }

/**
 * @param Generator $gen
 */
function stackedCoroutine(Generator $gen)
{
 $stack = new SplStack;
 // Continuously traverse this generator passed in for (; ;) {
  // $gen can be understood as pointing to the currently running coroutine closure function (generator)  $value = $gen->current(); // Get the breakpoint, which is the value produced by yield  if ($value instanceof Generator) {
   // If it is also a generator, this is a child coroutine. Put the currently running coroutine on the stack to save it   $stack->push($gen);
   $gen = $value; // Give the child coroutine function to gen and continue to execute. Note that the next step is to execute the child coroutine process.   continue;
  }
  // We have encapsulated the result returned by the child coroutine, and the following is  $isReturnValue = $value instanceof CoroutineReturnValue; // The child coroutine returns `$value` and requires the main coroutine to help deal with it.  if (!$gen->valid() || $isReturnValue) {
   if ($stack->isEmpty()) {
    return;
   }
   // If gen has been executed, or if the child coroutine needs to return the value to the main coroutine for processing   $gen = $stack->pop(); //Open the stack and get the main coroutine saved before it is put into the stack.   $gen->send($isReturnValue ? $value->getValue() : NULL); // Call the main coroutine to process the output value of the child coroutine   continue;
  }
  $gen->send(yield $gen->key() => $value); // Continue to execute the subcoroutine }
}

class CoroutineReturnValue {
 protected $value;
 
 public function __construct($value) {
  $this->value = $value;
 }
 // Get the output value of the child coroutine to the main coroutine as the send parameter of the main coroutine public function getValue() {
  return $this->value;
 }
}
function retval($value) {
 return new CoroutineReturnValue($value);
}

function echoTimes($msg, $max) {
 for ($i = 1; $i <= $max; ++$i) {
  echo "$msg iteration $i\n";
  yield;
 }
 yield retval(""); // Add this as the end mark}

function task1()
{
 yield echoTimes('bar', 5);
}

 public function __construct($taskId, Generator $coroutine)
 {
  $this->taskId = $taskId;
  $this->coroutine = $coroutine;
  // $this->coroutine = stackedCoroutine($coroutine); //No need to implement it yourself, change it back to the previous one }

function echoTimes($msg, $max) {
 for ($i = 1; $i <= $max; ++$i) {
  echo "$msg iteration $i\n";
  yield;
 }
}

function task1()
{
 yield from echoTimes('bar', 5);
}