PHP LoopInterface::nextTick方法代码示例

 /**
  * {@inheritdoc}
  */
 protected function setUp()
 {
     $app = new Container();
     $app->instance('config', new Repository());
     (new EventServiceProvider($app))->register();
     (new AmiServiceProvider($app))->register();
     $this->loop = $app[LoopInterface::class];
     $this->loop->nextTick(function () {
         if (!$this->running) {
             $this->loop->stop();
         }
     });
     $this->stream = $app[Stream::class];
     $this->events = $app['events'];
     $this->app = $app;
 }

 public function testMapEndWithPendingItems()
 {
     $map = map(function ($n, callable $callback) {
         $this->eventLoop->nextTick(function () use($callback, $n) {
             $callback(null, 2 * $n);
         });
     }, ['concurrency' => 5]);
     $items = [];
     $ended = false;
     $map->on('data', function ($n) use(&$items) {
         $items[] = $n;
     });
     $map->on('end', function () use(&$ended) {
         $ended = true;
     });
     for ($i = 0; $i < 10; $i++) {
         $map->write($i);
     }
     $map->end();
     $this->assertFalse($ended);
     $this->assertEmpty($items);
     $this->eventLoop->tick();
     $this->assertTrue($ended);
     $this->assertSame(range(0, 18, 2), $items);
 }

 /**
  * Start the event reactor and assume program flow control
  *
  * @param callable $onStart Optional callback to invoke immediately upon reactor start
  */
 public function run(callable $onStart = null)
 {
     if ($onStart) {
         $this->reactor->nextTick($onStart);
     }
     $this->reactor->run();
 }

 /**
  * Schedule a callback to be invoked on the next tick of the event loop.
  *
  * Callbacks are guaranteed to be executed in the order they are enqueued,
  * before any timer or stream events.
  *
  * @param callable $listener The callback to invoke.
  */
 public function nextTick(callable $listener)
 {
     $this->emit('nextTick', [$listener]);
     return $this->loop->nextTick(function (LoopInterface $loop) use($listener) {
         $this->emit('nextTickTick', [$listener]);
         $listener($this);
     });
 }

 public function testFutureTickEventGeneratedByNextTick()
 {
     $stream = $this->createStream();
     $this->loop->nextTick(function () {
         $this->loop->futureTick(function () {
             echo 'future-tick' . PHP_EOL;
         });
     });
     $this->expectOutputString('future-tick' . PHP_EOL);
     $this->loop->run();
 }

 /**
  * Continues the given flow.
  *
  * @param ReactFlow $flow
  * @param Packet    $packet
  */
 private function continueFlow(ReactFlow $flow, Packet $packet)
 {
     try {
         $response = $flow->next($packet);
     } catch (\Exception $e) {
         $this->emitError($e);
         return;
     }
     if ($response !== null) {
         if ($this->stream->getBuffer()->listening) {
             $this->sendingFlows[] = $flow;
         } else {
             $this->stream->write($response);
             $this->writtenFlow = $flow;
         }
     } elseif ($flow->isFinished()) {
         $this->loop->nextTick(function () use($flow) {
             $this->finishFlow($flow);
         });
     }
 }

 /**
  * @return \React\Promise\Promise|PromiseInterface
  */
 public function computeId()
 {
     $deferred = new Deferred();
     $this->loop->nextTick($this->doCompute($deferred));
     return $deferred->promise();
 }