PHP Thread::start方法代码示例

 /**
  * @expectedException RuntimeException
  */
 public function testThreadAlreadyJoined()
 {
     $thread = new Thread();
     $this->assertEquals($thread->start(), true);
     $this->assertEquals($thread->join(), true);
     $this->assertEquals($thread->join(), false);
 }

 /**
  * @expectedException RuntimeException
  */
 public function testThreadAlreadyJoined()
 {
     $thread = new Thread();
     $this->assertTrue($thread->start());
     $this->assertTrue($thread->join());
     $this->assertFalse($thread->join());
 }

 public function start($options = PTHREADS_INHERIT_ALL)
 {
     ThreadManager::getInstance()->add($this);
     if (!$this->isRunning() and !$this->isJoined() and !$this->isTerminated()) {
         return parent::start($options);
     }
     return false;
 }

 /**
  *	Starts new threads if needed
  *
  *	@return int	queue size
  */
 public function tick()
 {
     $this->cleanup();
     if (count($this->threads) < $this->queueSize && count($this->jobs)) {
         $this->threads[] = $szal = new Thread($this->callable);
         $szal->start(array_shift($this->jobs));
     }
     usleep(ThreadQueue::TICK_DELAY);
     return $this->queueSize();
 }

 function run()
 {
     while (true != $this->exit) {
         $sock = socket_accept($this->ls);
         if ($sock) {
             $hs = new Thread(new HttpHandler($sock, $this->handler));
             $hs->start();
         }
     }
 }

 static function start($transport, $nodename = null, $background = true)
 {
     $node = new LdwpNode();
     if ($background) {
         $t = new Thread($node);
         $pid = $t->start();
         console::writeLn("Forked with pid %d", $pid);
     } else {
         $node->threadmain();
     }
 }

 public function start(int $options = PTHREADS_INHERIT_ALL)
 {
     ThreadManager::getInstance()->add($this);
     if (!$this->isRunning() and !$this->isJoined() and !$this->isTerminated()) {
         if ($this->getClassLoader() === null) {
             $this->setClassLoader();
         }
         return parent::start($options);
     }
     return false;
 }

 public function handle(\Thread $thread)
 {
     $thread->start();
     echo "Start thread with ID {$thread->getCurrentThreadId()}\n";
     return Observable::create(function (ObserverInterface $observer) use($thread) {
         while ($thread->isRunning()) {
             $this->loop->tick();
         }
         try {
             echo "Thread finished\n";
             $thread->join();
             $observer->onNext(new Event('/thread/ok', $thread));
             $observer->onCompleted();
         } catch (\Exception $e) {
             echo "Thread error\n";
             $observer->onError($e);
         }
         unset($thread);
     });
 }

 /**
  * {@inheritdoc}
  */
 protected function spawnWorker() : Awaitable
 {
     if (self::$sharedWorkers === null) {
         self::$sharedWorkers = [];
         \register_shutdown_function(function () {
             self::shutdownPool();
         });
     }
     $index = self::$allocated++ % self::getMaxSize();
     if (isset(self::$sharedWorkers[$index])) {
         return new Success(self::$sharedWorkers[$index]);
     }
     try {
         list($a, $b) = Socket::createPair();
         $thread = new Thread($b, self::getComposerAutoloader());
         $thread->start(\PTHREADS_INHERIT_INI);
         return new Success(self::$sharedWorkers[$index] = new ThreadWorker($index, $a, $thread));
     } catch (\Throwable $e) {
         self::$allocated--;
         return new Failure($e);
     }
 }

<?php

require "thread.php";
echo "Hola que talllll";
function proceso($tiempo, $resultado)
{
    usleep($tiempo);
    exit($resultado);
}
$thread1 = new Thread('proceso');
$thread2 = new Thread('proceso');
$thread3 = new Thread('proceso');
$thread1->start(3, 10);
$thread2->start(2, 40);
$thread3->start(1, 30);
while ($thread1->isAlive() || $thread2->isAlive() || $thread3->isAlive()) {
}
echo "Resultado del hilo 1 (debe ser 3): " . $thread1->getExitCode() . "\n";
echo "Resultado del hilo 2 (debe ser 2): " . $thread2->getExitCode() . "\n";
echo "Resultado del hilo 3 (debe ser 1): " . $thread3->getExitCode() . "\n";

 /**
  * Start the thread
  *
  * @throws \RuntimeException
  */
 public function execute()
 {
     $this->args = func_get_args();
     return parent::start();
 }

 public final function start($options = PTHREADS_INHERIT_ALL)
 {
     ThreadManager::getInstance()->add($this);
     return parent::start($options);
 }

<?php

/**
* This file serves as a benchmark for pthreads initialization/destruction
* usage: php-zts examples/Benchmark.php [threads] [samples]
*   threads - the number of threads to create, default=100
*   samples - the number of times to run the test, default=5
*/
/**
* Nothing
*/
$max = @$argv[1] ? $argv[1] : 100;
$sample = @$argv[2] ? $argv[2] : 5;
printf("Start(%d) ...", $max);
$it = 0;
do {
    $s = microtime(true);
    /* begin test */
    $ts = [];
    while (count($ts) < $max) {
        $t = new Thread();
        $t->start();
        $ts[] = $t;
    }
    $ts = [];
    /* end test */
    $ti[] = $max / (microtime(true) - $s);
    printf(".");
} while ($it++ < $sample);
printf(" %.3f tps\n", array_sum($ti) / count($ti));

 private function spawnWorker()
 {
     $results = new SharedData();
     $resultCodes = new SharedData();
     $thread = new Thread($results, $resultCodes, $this->ipcUri);
     if (!$thread->start()) {
         throw new \RuntimeException('Worker thread failed to start');
     }
     $worker = new Worker();
     $worker->id = $thread->getThreadId();
     $worker->results = $results;
     $worker->resultCodes = $resultCodes;
     $worker->thread = $thread;
     $this->pendingWorkers[$worker->id] = $worker;
     $this->pendingWorkerCount++;
     return $worker;
 }

 /**
  * Spawns the module's logic in a new worker thread.
  */
 public function start()
 {
     $stopRequested = false;
     parent::start(PTHREADS_INHERIT_NONE);
 }