PHP SplQueue::shift方法代码示例

 /**
  * @coroutine
  *
  * @return \Generator
  *
  * @resolve \Icicle\Postgres\Connection
  */
 private function pop() : \Generator
 {
     while (null !== $this->awaitable) {
         try {
             (yield $this->awaitable);
             // Prevent simultaneous connection creation.
         } catch (\Throwable $exception) {
             // Ignore failure or cancellation of other operations.
         }
     }
     if ($this->idle->isEmpty()) {
         try {
             if ($this->connections->count() >= $this->getMaxConnections()) {
                 // All possible connections busy, so wait until one becomes available.
                 $this->awaitable = new Delayed();
                 (yield $this->awaitable);
             } else {
                 // Max connection count has not been reached, so open another connection.
                 $this->awaitable = new Coroutine($this->createConnection());
                 $this->addConnection((yield $this->awaitable));
             }
         } finally {
             $this->awaitable = null;
         }
     }
     // Shift a connection off the idle queue.
     return $this->idle->shift();
 }

 /**
  * {@inheritdoc}
  */
 public function tick()
 {
     if (!$this->queue->isEmpty()) {
         $immediate = $this->queue->shift();
         $this->immediates->detach($immediate);
         // Execute the immediate.
         $immediate->call();
         return true;
     }
     return false;
 }

 /**
  * Executes each callback that was in the queue when this method is called up to the maximum depth.
  * 
  * @return int Number of functions called.
  */
 public function call() : int
 {
     $count = 0;
     while (!$this->queue->isEmpty() && (0 === $this->maxDepth || $count < $this->maxDepth)) {
         list($callback, $args) = $this->queue->shift();
         ++$count;
         if (empty($args)) {
             $callback();
         } else {
             call_user_func_array($callback, $args);
         }
     }
     return $count;
 }

 /**
  * {@inheritdoc}
  */
 public function close()
 {
     if ($this->open && $this->worker->isRunning()) {
         $coroutine = new Coroutine($this->worker->enqueue(new Internal\FileTask('fclose', [], $this->id)));
         $coroutine->done(null, [$this->worker, 'kill']);
     }
     if (!$this->queue->isEmpty()) {
         $exception = new FileException('The file was closed.');
         do {
             $this->queue->shift()->cancel($exception);
         } while (!$this->queue->isEmpty());
     }
     $this->open = false;
     $this->writable = false;
 }

 /**
  * @param $db_sock
  * @return bool
  */
 public function onSQLReady($db_sock)
 {
     $task = empty($this->work_pool[$db_sock]) ? null : $this->work_pool[$db_sock];
     if (empty($task)) {
         #echo "MySQLi Warning: Maybe SQLReady receive a Close event , such as Mysql server close the socket !\n";
         if (isset($this->idle_pool[$db_sock])) {
             $this->removeConnection($this->idle_pool[$db_sock]);
         }
         return false;
     }
     /**
      * @var \mysqli $mysqli
      */
     $mysqli = $task['mysql']['object'];
     $callback = $task['callback'];
     if ($result = $mysqli->reap_async_query()) {
         call_user_func($callback, $mysqli, $result);
         if (is_object($result)) {
             mysqli_free_result($result);
         }
     } else {
         call_user_func($callback, $mysqli, $result);
         #echo "MySQLi Error: " . mysqli_error($mysqli) . "\n";
     }
     //release mysqli object
     unset($this->work_pool[$db_sock]);
     if ($this->pool_size < $this->connection_num) {
         //减少连接数
         $this->removeConnection($task['mysql']);
     } else {
         $this->idle_pool[$task['mysql']['socket']] = $task['mysql'];
         //fetch a request from wait queue.
         if (count($this->wait_queue) > 0) {
             $idle_n = count($this->idle_pool);
             for ($i = 0; $i < $idle_n; $i++) {
                 $new_task = $this->wait_queue->shift();
                 $this->doQuery($new_task['sql'], $new_task['callback']);
             }
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function read(int $length = 0, string $byte = null, float $timeout = 0) : \Generator
 {
     while (null !== $this->delayed) {
         (yield $this->delayed);
     }
     if (!$this->isReadable()) {
         throw new UnreadableException('The stream is no longer readable.');
     }
     $this->length = $length;
     if (0 > $this->length) {
         throw new InvalidArgumentError('The length should be a positive integer.');
     }
     $this->byte = strlen($byte) ? $byte[0] : null;
     if (!$this->buffer->isEmpty()) {
         $data = $this->remove();
         if (0 !== $this->hwm && $this->buffer->getLength() <= $this->hwm) {
             while (!$this->queue->isEmpty()) {
                 /** @var \Icicle\Awaitable\Delayed $delayed */
                 $delayed = $this->queue->shift();
                 $delayed->resolve();
             }
         }
         if (!$this->writable && $this->buffer->isEmpty()) {
             $this->free();
         }
         return $data;
     }
     $awaitable = $this->delayed = new Delayed();
     if ($timeout) {
         $awaitable = $this->delayed->timeout($timeout);
     }
     try {
         $data = (yield $awaitable);
     } finally {
         $this->delayed = null;
     }
     return $data;
 }

 public function send($data = null)
 {
     //锁定状态写入队列
     if (!empty($data)) {
         $this->queue->push($data);
     }
     if ($this->reconn) {
         Trace::debug("*********cli {$this->fd} reconn \n");
         $this->cli->connect($this->conf['ip'], $this->conf['port']);
         $this->reconn = false;
         $this->lock = true;
     }
     if ($this->queue->isEmpty()) {
         $this->lock = false;
     } elseif (!$this->lock) {
         $this->lock = true;
         $data = $this->queue->shift();
         Trace::debug("*********cli {$this->fd} send " . strlen($data) . "\n==================\n" . substr($data, 0, 50) . "...\n==============");
         Trace::info(sprintf("Host: %-25s %s", $this->conf['host'], strstr($data, "\n", true)));
         //;'Host:' . $this->conf['host'] . strstr($data, "\n", true)
         $this->cli->send($data);
     }
 }

 /**
  * @param string $data
  *
  * @return \Icicle\Awaitable\Delayed
  *
  * @throws \Icicle\File\Exception\FileException
  */
 private function push(string $data) : Awaitable
 {
     $length = strlen($data);
     $delayed = new Delayed();
     \eio_write($this->handle, $data, $length, $this->append ? $this->size : $this->position, null, function (Delayed $delayed, $result, $req) use($length) {
         if (-1 === $result) {
             $delayed->reject(new FileException(sprintf('Writing to the file failed: %s.', \eio_get_last_error($req))));
         } elseif ($this->queue->isEmpty()) {
             $delayed->reject(new FileException('No pending write, the file may have been closed.'));
         } else {
             $this->queue->shift();
             if ($this->append) {
                 $this->size += $result;
             } else {
                 $this->position += $result;
                 if ($this->position > $this->size) {
                     $this->size = $this->position;
                 }
             }
             $delayed->resolve($result);
         }
     }, $delayed);
     return $delayed;
 }

 /**
  * Converts a function accepting a callback ($emitter) that invokes the callback when an event is emitted into an
  * observable that emits the arguments passed to the callback function each time the callback function would be
  * invoked.
  *
  * @param callable<(mixed ...$args)> $emitter Function accepting a callback that periodically emits events.
  * @param int $index Position of callback function in emitter function argument list.
  * @param mixed ...$args Other arguments to pass to emitter function.
  *
  * @return \Icicle\Observable\Observable
  */
 function observe(callable $emitter, int $index = 0, ...$args) : Observable
 {
     return new Emitter(function (callable $emit) use($emitter, $index, $args) : \Generator {
         $queue = new \SplQueue();
         /** @var \Icicle\Awaitable\Delayed $delayed */
         $callback = function (...$args) use(&$delayed, $queue) {
             if (null !== $delayed) {
                 $delayed->resolve($args);
                 $delayed = null;
             } else {
                 $queue->push($args);
             }
         };
         if (count($args) < $index) {
             throw new InvalidArgumentError('Too few arguments given to function.');
         }
         array_splice($args, $index, 0, [$callback]);
         $emitter(...$args);
         while (true) {
             if ($queue->isEmpty()) {
                 $delayed = new Delayed();
                 yield from $emit($delayed);
             } else {
                 yield from $emit($queue->shift());
             }
         }
     });
 }

 /**
  * @param $db
  * @param null $_result
  * @return bool
  */
 public function onSQLReady($db, $_result = null)
 {
     $db_sock = $this->haveSwooleAsyncMySQL ? $db->sock : $db;
     $task = empty($this->work_pool[$db_sock]) ? null : $this->work_pool[$db_sock];
     //SQL返回了错误
     if ($_result === false) {
         //连接已关闭
         if (empty($task) or $this->haveSwooleAsyncMySQL and $db->_connected == false) {
             unset($this->work_pool[$db_sock]);
             $this->removeConnection($task['mysql']);
             //创建连接成功
             if ($this->createConnection() === 0) {
                 $this->doQuery($task['sql'], $task['callback']);
             } else {
                 $this->wait_queue->push(array('sql' => $task['sql'], 'callback' => $task['callback']));
             }
             return;
         }
     }
     /**
      * @var \mysqli $mysqli
      */
     $mysqli = $task['mysql']['object'];
     $callback = $task['callback'];
     if ($this->haveSwooleAsyncMySQL) {
         call_user_func($callback, $mysqli, $_result);
     } else {
         $mysqli->_affected_rows = $mysqli->affected_rows;
         $mysqli->_insert_id = $mysqli->insert_id;
         $mysqli->_errno = $mysqli->errno;
         $mysqli->_error = $mysqli->error;
         if ($_sql_result = $mysqli->reap_async_query()) {
             if ($_sql_result instanceof \mysqli_result) {
                 $result = $_sql_result->fetch_all();
             } else {
                 $result = $_sql_result;
             }
             call_user_func($callback, $mysqli, $result);
             if (is_object($result)) {
                 mysqli_free_result($result);
             }
         } else {
             call_user_func($callback, $mysqli, false);
         }
     }
     //release mysqli object
     unset($this->work_pool[$db_sock]);
     if ($this->pool_size < $this->connection_num) {
         //减少连接数
         $this->removeConnection($task['mysql']);
     } else {
         deQueue:
         $this->idle_pool[$task['mysql']['socket']] = $task['mysql'];
         $queue_count = count($this->wait_queue);
         //fetch a request from wait queue.
         if ($queue_count > 0) {
             $task_n = count($this->idle_pool);
             if ($task_n > $queue_count) {
                 $task_n = $queue_count;
             }
             for ($i = 0; $i < $task_n; $i++) {
                 $new_task = $this->wait_queue->shift();
                 $this->doQuery($new_task['sql'], $new_task['callback']);
             }
         }
     }
 }

 public function fire($job, $message)
 {
     $this->warnings = array();
     $commit = $message['commit'];
     $hostType = $message['hostType'];
     $siteId = $message['siteId'];
     $dc = new DC($siteId);
     $staticDir = $dc->get(DC::STATIC_DIR);
     if (isset($message['type']) && $message['type'] == self::TYPE_PULL_REQUEST) {
         $id = $message['id'];
         $this->type = self::TYPE_PULL_REQUEST;
         $this->pr = new PullRequestDeploy($siteId);
         $this->prDeployInfo = $this->pr->get($id);
         $root = (new SystemConfig())->get(SystemConfig::WORK_ROOT_FIELD) . '/' . $siteId . '/pull_requests';
         $commitPath = "{$root}/commit/{$commit}";
     } else {
         $this->type = self::TYPE_NORMAL_DEPLOY;
         $this->dfManger = new DeployInfo($siteId);
         $id = $message['id'];
         $this->deployInfo = $this->dfManger->get($id);
         $root = (new SystemConfig())->get(SystemConfig::WORK_ROOT_FIELD) . '/' . $siteId . '/commit';
         $commitPath = "{$root}/{$commit}";
     }
     $LOCAL_STATIC_DIR = "{$commitPath}/{$staticDir}";
     $LOCAL_DIR = $commitPath;
     $remoteUser = $dc->get(DC::REMOTE_USER);
     $remoteOwner = $dc->get(DC::REMOTE_OWNER);
     $RSYNC_EXCLUDE = "{$commitPath}/" . $dc->get(DC::RSYNC_EXCLUDE);
     $REMOTE_STATIC_DIR = $dc->get(DC::REMOTE_STATIC_DIR);
     $REMOTE_DIR = $dc->get(DC::REMOTE_APP_DIR);
     $staticScript = ScriptCommand::complie($dc->get(DC::DEPLOY_STATIC_SCRIPT), $siteId);
     $webScript = ScriptCommand::complie($dc->get(DC::DEPLOY_WEB_SCRIPT), $siteId);
     $this->updateStatus('Deploying');
     Log::info("\n---------------------------\njob id : {$job->getJobId()} start ");
     Log::info("commit deploy: {$commit}");
     //本地同步锁，不能在同一个commit下同步
     $redis = app('redis')->connection();
     $commitLock = new \Eleme\Rlock\Lock($redis, JobLock::buildLock($commitPath), array('timeout' => 600000, 'blocking' => false));
     if (!$commitLock->acquire()) {
         Log::info("Job : {$job->getJobId()} Release");
         $job->release(30);
     }
     $rsyLock = NULL;
     try {
         $hosts = (new SiteHost($siteId, $hostType, SiteHost::STATIC_HOST))->getList();
         $staticHosts = new SplQueue();
         foreach ($hosts as $h) {
             $staticHosts->push($h);
         }
         $hosts = (new SiteHost($siteId, $hostType, SiteHost::WEB_HOST))->getList();
         $webHosts = new SplQueue();
         foreach ($hosts as $h) {
             $webHosts->push($h);
         }
         /*****************************************
          *
          *  执行静态文件同步
          *
          *****************************************/
         //执行同步前本地命令
         $this->processCommands($staticScript['before']['handle']);
         while (!$staticHosts->isEmpty()) {
             $host = $staticHosts->shift();
             $rsyLock = new \Eleme\Rlock\Lock($redis, JobLock::rsyLock($host['hostip']), array('timeout' => 600000, 'blocking' => false));
             if ($rsyLock->acquire()) {
                 try {
                     $HOST_NAME = $host['hostname'];
                     //执行同步前每次都执行的本地命令
                     $this->processCommands($staticScript['before']['local']);
                     //执行同步前每次都执行的远端命令
                     $this->processCommands($staticScript['before']['remote'], $HOST_NAME);
                     Log::info("deploying static files to {$HOST_NAME}.");
                     (new Process($this->remoteProcess($HOST_NAME, "sudo mkdir -p {$REMOTE_STATIC_DIR}")))->mustRun();
                     (new Process($this->remoteProcess($HOST_NAME, "sudo chown {$remoteUser} -R {$REMOTE_STATIC_DIR}")))->mustRun();
                     (new Process("rsync -az --progress --force --delay-updates --exclude-from={$RSYNC_EXCLUDE} {$LOCAL_STATIC_DIR}/ {$HOST_NAME}:{$REMOTE_STATIC_DIR}/", $commitPath))->setTimeout(600)->mustRun();
                     (new Process($this->remoteProcess($HOST_NAME, "sudo chown {$remoteOwner} -R {$REMOTE_STATIC_DIR}")))->mustRun();
                     //执行同步后每次都执行的本地命令
                     $this->processCommands($staticScript['after']['local']);
                     //执行同步后每次都执行的远端命令
                     $this->processCommands($staticScript['after']['remote'], $HOST_NAME);
                     $rsyLock->release();
                 } catch (Exception $e) {
                     $rsyLock->release();
                     throw $e;
                 }
             } else {
                 // 正在同步，重新放回队列
                 $staticHosts->push($host);
             }
         }
         //执行同步后本地命令
         $this->processCommands($staticScript['after']['handle']);
         /*****************************************
          *
          *  执行WEB应用同步
          *
          *****************************************/
         //执行同步前本地命令
         $this->processCommands($webScript['before']['handle']);
         while (!$webHosts->isEmpty()) {
//.........这里部分代码省略.........

 /**
  * @param resource $resource
  * @param \SplQueue $queue
  *
  * @return \Icicle\Loop\Watcher\Io
  */
 private function createPoll($resource, \SplQueue $queue) : Io
 {
     return Loop\poll($resource, static function ($resource, bool $expired) use($queue) {
         /** @var \Icicle\Awaitable\Delayed $delayed */
         $delayed = $queue->shift();
         if ($expired) {
             $delayed->reject(new TimeoutException('The connection timed out.'));
             return;
         }
         $delayed->resolve();
     });
 }

 /**
  * @param resource $resource
  * @param \SplQueue $queue
  *
  * @return \Icicle\Loop\Watcher\Io
  */
 private function createPoll($resource, \SplQueue $queue) : Io
 {
     return Loop\poll($resource, static function ($resource, bool $expired, Io $poll) use($queue) {
         // Error reporting suppressed since stream_socket_accept() emits E_WARNING on client accept failure.
         $socket = @stream_socket_accept($resource, 0);
         // Timeout of 0 to be non-blocking.
         // Having difficulty finding a test to cover this scenario, but it has been seen in production.
         if (!$socket) {
             $poll->listen();
             // Accept failed, let's go around again.
             return;
         }
         /** @var \Icicle\Awaitable\Delayed $delayed */
         $delayed = $queue->shift();
         $delayed->resolve($socket);
     });
 }

 public function stateStatement(Token $token)
 {
     $lval = strtolower($token->value);
     switch ($token->type) {
         case Token::LCURLY:
         case Token::RCURLY:
             $this->curlyLevel += $token->type === Token::LCURLY ? +1 : -1;
         case Token::SEMICOLON:
             $this->appendStatement($token);
             $this->dumpStatement();
             $this->transition(self::PHP);
             return false;
         case Token::DOT:
             // check if it' just before a "should" token
             $next = $this->skip(Token::WHITESPACE, Token::EOL);
             if ($next->type === Token::IDENT && strtolower($next->value) === 'should') {
                 // Replace it with a single whitespace
                 $token = new Token(Token::WHITESPACE, ' ');
                 $this->appendStatement($token);
                 return $next;
             }
             $this->appendStatement($token);
             return $next;
         case $token->value === '__DIR__':
             $token->value = self::SPEC_CLASS . '::dir(__DIR__)';
             $this->appendStatement($token);
             return false;
         case $lval === 'should':
             // Flush captured non-statement tokens
             while (!$this->statement->isEmpty()) {
                 $token = $this->statement->bottom();
                 if ($token->type === Token::COMMENT || $token->type === Token::WHITESPACE || $token->type === Token::EOL) {
                     $this->write($token->value);
                     $this->statement->shift();
                 } else {
                     break;
                 }
             }
             // Define the expectation wrapper
             $this->write(self::SPEC_CLASS . '::expect(');
             $this->dumpStatement();
             $this->write(')->');
             $this->transition(self::SHOULD);
             return false;
         case $lval === '$this':
             switch (strtoupper($this->blocks->top())) {
                 case 'DESCRIBE':
                 case 'BEFORE':
                 case 'AFTER':
                     $token->value = self::SPEC_CLASS . '::suite()';
                     break;
                 case 'BEFORE_EACH':
                 case 'AFTER_EACH':
                 case 'IT':
                     $token->value = self::SPEC_CLASS . '::test()';
                     break;
             }
         default:
             if ($token->token === T_CLOSE_TAG) {
                 $this->dumpStatement();
                 $this->transition(self::PHP);
                 return $token;
             }
             $this->appendStatement($token);
             return false;
     }
 }

<?php

$queue = new SplQueue();
// errors
try {
    $queue->dequeue();
} catch (RuntimeException $e) {
    echo "Exception: " . $e->getMessage() . "\n";
}
try {
    $queue->shift();
} catch (RuntimeException $e) {
    echo "Exception: " . $e->getMessage() . "\n";
}
// data consistency
$a = 2;
$queue->enqueue($a);
echo $queue->dequeue() . "\n";
// peakable
$queue->enqueue(1);
$queue->enqueue(2);
echo $queue->top() . "\n";
// iterable
foreach ($queue as $elem) {
    echo "[{$elem}]\n";
}
// countable
$queue->enqueue(NULL);
$queue->enqueue(NULL);
echo count($queue) . "\n";
echo $queue->count() . "\n";