php教程

Pool::collect

(PECL pthreads >= 2.0.0)

Pool::collect — 回收已完成任务的引用

说明

public Pool::collect ([ Callable $collector ] ) : int

对于视为垃圾的引用，使用给定的垃圾收集器进行收集

参数

collector

垃圾收集器，它返回一个布尔值表示这个任务是否可以被进行垃圾收集。 仅在极少的情况下需要一个自定义的垃圾收集器。

返回值

池中剩余的待收集的任务数量。

更新日志

版本 说明
v3 collector 参数变为可选参数， 并且返回值改为整数。

范例

Example #1 Pool::collect() 基本用法示例

<?php
$pool = new Pool(4);

for ($i = 0; $i < 15; ++$i) {
    $pool->submit(new class extends Threaded {});
}

while ($pool->collect()); // 直到全部的任务都完成执行之后才会继续下面的代码

$pool->shutdown();

User Contributed Notes

l00k at protonmail dot com 02-Dec-2017 04:05
This example demonstrates various aspects of MTP with pthreads - esspecially worth of note is bidirectional communication with child threads.
I could not find anything about that so I would like to present you my research result.

<?php

class Model
{
   
    public $id;
    public $value;
   
}

class Connection
    extends Worker
{
   
    protected static $link;
   
   
    public function __construct($hostname, $username, $password, $database, $port = 3306)
    {
        $this->hostname = $hostname;
        $this->username = $username;
        $this->password = $password;
        $this->database = $database;
        $this->port = $port;
    }
   
    public function getConnection()
    {
        if(!self::$link)
        {
            echo 'Thread: '. $this->getThreadId() ." Connecting to db\n";
            self::$link = new \PDO(...);
        }
       
        return self::$link;
    }
   
}

/** @property Connection $worker */
class QueryTask
    extends Threaded
{
   
    public $data;
    public $result;
   
    protected $_complete;
   
   
    public function __construct(Model $data)
    {
        $this->_complete = false;
        $this->data = $data;
    }
   
    public function run()
    {
        /** @var \PDO $pdo */
        $pdo = $this->worker->getConnection();
       
        $text = 'Thread: '. $this->worker->getThreadId() .' Job: '. $this->data->id .' Data: '. $this->data->value;
       
        $t = microtime(true);
       
        $stmt = $pdo->prepare("
            INSERT INTO `test` (`id`, `text`) VALUES (NULL, '". $text ."')
        ");
        $stmt->execute();
       
        $dt = microtime(true) - $t;
       
        $result = (int) $stmt->rowCount();
       
        echo $text .' Result: '. $result .' Exec time: '. $dt ."s\n";
       
        $this->result = $result;
        $this->_complete = true;
    }
   
    public function isGarbage() : bool
    {
        return $this->_complete;
    }
   
}

$t = microtime(true);

// uruchomienie
$pool = new Pool(5, 'Connection', [ 'localhost', 'root', 'password', 'test' ]);

// zadania
$tasks = 10;

for($i=0; $i<$tasks; ++$i)
{
    $object = new Model();
    $object->id = $i;
    $object->value = rand();

    $pool->submit(new QueryTask($object));
}

// oczekiwanie na zakonczenie
$data = [];

while(1)
{
    $newData = [];

    $pool->collect(function(QueryTask $task) use (&$newData) {
        if($task->isGarbage())
        {
            $tmpObj = new stdclass();
            $tmpObj->complete = $task->complete;
           
            $newData[ $task->data->id ] = $task->data->value;
        }
       
        return $task->isGarbage();
    });
   
    $data = array_merge($data, $newData);
   
    if(count($data) == $tasks)
        break;
   
    usleep(100000);
}

var_dump($data);
?>

Result:
Thread: 6796 Connecting to db
Thread: 3156 Connecting to db
Thread: 9040 Connecting to db
Thread: 7748 Connecting to db
Thread: 8836 Connecting to db
Job: 0 Done in: 0.0070011615753174s
Job: 4 Done in: 0.0069999694824219s
Job: 2 Done in: 0.0090010166168213s
Job: 3 Done in: 0.0090010166168213s
Job: 1 Done in: 0.003000020980835s
Job: 5 Done in: 0.0069999694824219s
Job: 7 Done in: 0.0079998970031738s
Job: 6 Done in: 0.0049998760223389s
Job: 9 Done in: 0.0079998970031738s
Job: 8 Done in: 0.0069999694824219s

array(10) {
  [0] =>
  int(17730)
  [1] =>
  int(18771)
  [2] =>
  int(12944)
  [3] =>
  int(6025)
  [4] =>
  int(29582)
  [5] =>
  int(10159)
  [6] =>
  int(26556)
  [7] =>
  int(9029)
  [8] =>
  int(15002)
  [9] =>
  int(4043)
}

Things worth noting here:
1. Constructing of 5 workers for 10 tasks. 5 last task are runned on existing threads with already set up connection to db.
2. You can "send" data to thread by creating new task and submiting it.
3. You can retrive result by collect function.
4. You can pass simple object to task constructor.
meadowsjared at gmail dot com 14-Mar-2016 07:13
Please note, when using the collect function, it's important that you extend the pool class so you can keep checking for finished threads until they're all done.

<?php
class TestWork extends Threaded {
    protected $complete;
    //$pData is the data sent to your worker thread to do it's job.
    public function __construct($pData){
        //transfer all the variables to local variables
        $this->complete = false;
        $this->testData = $pData;
    }
    //This is where all of your work will be done.
    public function run(){
        usleep(2000000); //sleep 2 seconds to simulate a large job
        $this->complete = true;
    }
    public function isGarbage() {
        return $this->complete;
    }
}
class ExamplePool extends Pool
{
    public $data = array();
    public function process()
    {
        // Run this loop as long as we have
        // jobs in the pool
        while (count($this->work)) {
            $this->collect(function (TestWork $task) {
                // If a task was marked as done
                // collect its results
                if ($task->isGarbage()) {
                    $tmpObj = new stdclass();
                    $tmpObj->complete = $task->complete;
                    //this is how you get your completed data back out [accessed by $pool->process()]
                    $this->data[] = $tmpObj;
                }
                return $task->isGarbage();
            });
        }
        // All jobs are done
        // we can shutdown the pool
        $this->shutdown();
        return $this->data;
    }
}
$pool = new ExamplePool(3);
$testData = 'asdf';
for($i=0;$i<5;$i++) {
    $pool->submit(new TestWork($testData));
}
$retArr = $pool->process(); //get all of the results
echo '<pre>';
print_r($retArr); //return the array of results (and maybe errors)
echo '</pre>';
?>
your dot brother dot t at hotmail dot com 29-Dec-2014 09:33
The example code crashes and made me waste 2 working days
First of all, `Stackable` has no attribute named $worker or it's access method made it inaccessible.

Secondly, `Stackable` also doesn't have `getThreadId()` . It's best practice to use `Thread` class for realization of a thread since it has more control functions. It's better to use `Stackable` for object storage and use it's `run()` as its initialization.

The working example is

<?php
    class MyWork extends Thread {
        protected $complete;

        public function __construct() {
            $this->complete = false;
        }

        public function run() {
            printf(
                "Hello from %s in Thread #%lu\n",
                __CLASS__, $this->getThreadId());
            $this->complete = true;
        }

        public function isComplete() {
            return $this->complete;
        }
    }

    class Something {}

    class MyWorker extends Worker {

        public function __construct(Something $something) {
            $this->something = $something;
        }

        public function run() {
            /** ... **/
        }
    }

    $pool = new Pool(8, \MyWorker::class, [new Something()]);
    $pool->submit(new MyWork());

    usleep(1000);

    $pool->collect(function($work){
        return $work->isComplete();
    });
    var_dump($pool);
?>

CopyRight © 2008-2022 verySource.Com All Rights reserved.　京ICP备17048824号-1　京公网安备：11010502034788