Merge pull request #436 from bakedpotat0/pthreads_v3

Update pthreads stub based on latest docs (v3.1.6)
2018-11-16 16:40:24 +03:00 · 2018-11-16 16:40:24 +03:00 · 67268eaee8
parent 4c221838f5 fdfdcd1e1b
commit 67268eaee8
1 changed files with 272 additions and 183 deletions
--- a/pthreads/pthreads.php
+++ b/pthreads/pthreads.php
@ -1,6 +1,6 @@
 <?php

-// Start of PECL pthreads 2.0.4
+// Start of PECL pthreads 3.1.6

 /**
 * The default options for all Threads, causes pthreads to copy the environment
@ -55,9 +55,10 @@ define('PTHREADS_INHERIT_COMMENTS', 1048576);
 * Allow new Threads to send headers to standard output (normally prohibited)
 * @link https://php.net/manual/en/pthreads.constants.php
 */
-define('PTHREADS_ALLOW_HEADERS', 16777216);
+define('PTHREADS_ALLOW_HEADERS', 268435456);

 /**
+ * (PECL pthreads &gt;= 2.0.0)<br/>
 * A Pool is a container for, and controller of, an adjustable number of
 * Workers.<br/>
 * Pooling provides a higher level abstraction of the Worker functionality,
@ -67,7 +68,7 @@ define('PTHREADS_ALLOW_HEADERS', 16777216);
 class Pool {
    /**
     * Maximum number of Workers this Pool can use
-     * @var integer
+     * @var int
     */
    protected $size;

@ -89,81 +90,87 @@ class Pool {
     */
    protected $workers;

-    /**
-     * References to Threaded objects submitted to the Pool
-     * @var array
-     */
-    protected $work;
-
    /**
     * Offset in workers of the last Worker used
-     * @var integer
+     * @var int
     */
    protected $last;

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Creates a new Pool of Workers
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Construct a new pool of workers. Pools lazily create their threads, which means
+     * new threads will only be spawned when they are required to execute tasks.
     * @link https://secure.php.net/manual/en/pool.construct.php
-     * @param integer $size <p>The maximum number of Workers this Pool can create</p>
-     * @param string $class <p>The class for new Workers</p>
-     * @param array $ctor <p>An array of arguments to be passed to new Workers</p>
+     * @param int $size <p>The maximum number of workers for this pool to create</p>
+     * @param string $class [optional] <p>The class for new Workers. If no class is
+     * given, then it defaults to the {@link Worker} class.</p>
+     * @param array $ctor [optional] <p>An array of arguments to be passed to new
+     * Workers</p>
     */
-    public function __construct( $size, $class, $ctor=[] ) {}
+    public function __construct( $size, $class = 'Worker', $ctor = [] ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Allows the Pool to collect references determined to be garbage by the
-     * given collector
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Allows the pool to collect references determined to be garbage by the
+     * optionally given collector
     * @link https://secure.php.net/manual/en/pool.collect.php
-     * @param Callable $collector
-     * @return void
+     * @param callable $collector [optional] <p>A Callable collector that returns a
+     * boolean on whether the task can be collected or not. Only in rare cases should
+     * a custom collector need to be used.</p>
+     * @return int <p>The number of remaining tasks in the pool to be collected</p>
     */
-    public function collect( $collector ) {}
+    public function collect( $collector = null ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Resize the Pool
     * @link https://secure.php.net/manual/en/pool.resize.php
-     * @param integer $size <p>The maximum number of Workers this Pool can create</p>
+     * @param int $size <p>The maximum number of Workers this Pool can create</p>
     * @return void
     */
    public function resize( $size ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Shutdown the Workers in this Pool
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Shuts down all of the workers in the pool. This will block until all submitted
+     * tasks have been executed.
     * @link https://secure.php.net/manual/en/pool.shutdown.php
     * @return void
     */
    public function shutdown() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Submit the task to the next Worker in the Pool
     * @link https://secure.php.net/manual/en/pool.submit.php
-     * @param Threaded $task
-     * @return integer <p>the identifier of the Worker executing the object</p>
+     * @param Threaded $task <p>The task for execution</p>
+     * @return int <p>the identifier of the Worker executing the object</p>
     */
    public function submit( $task ) {}

    /**
-     * Submit the object to the specified Worker in the Pool
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Submit a task to the specified worker in the pool. The workers are indexed
+     * from 0, and will only exist if the pool has needed to create them (since
+     * threads are lazily spawned).
     * @link https://secure.php.net/manual/en/pool.submitTo.php
-     * @param integer $worker <p>The worker for execution</p>
+     * @param int $worker <p>The worker to stack the task onto, indexed from 0</p>
     * @param Threaded $task <p>The task for execution</p>
-     * @return integer <p>the identifier of the Worker that accepted the object</p>
+     * @return int <p>The identifier of the worker that accepted the task</p>
     */
    public function submitTo( $worker, $task ) {}
 }

 /**
 * Threaded objects form the basis of pthreads ability to execute user code
- * asynchronously; they expose and include synchronization methods and various
- * useful interfaces.
+ * in parallel; they expose synchronization methods and various useful
+ * interfaces.<br/>
+ * Threaded objects, most importantly, provide implicit safety for the programmer;
+ * all operations on the object scope are safe.
+ *
 * @link https://secure.php.net/manual/en/class.threaded.php
 */
-class Threaded implements Traversable, Countable, ArrayAccess {
+class Threaded implements Collectable, Traversable, Countable, ArrayAccess {
    /**
     * Worker object in which this Threaded is being executed
     * @var Worker
@ -171,26 +178,56 @@ class Threaded implements Traversable, Countable, ArrayAccess {
    protected $worker;

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 3.0.0)<br/>
+     * Increments the internal number of references to a Threaded object
+     * @return void
+     */
+    public function addRef() {}
+
+    /**
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Fetches a chunk of the objects property table of the given size,
     * optionally preserving keys
     * @link https://secure.php.net/manual/en/threaded.chunk.php
-     * @param integer $size <p>The number of items to fetch</p>
-     * @param boolean $preserve <p>Preserve the keys of members, by default false</p>
+     * @param int $size <p>The number of items to fetch</p>
+     * @param bool $preserve [optional] <p>Preserve the keys of members, by default false</p>
     * @return array <p>An array of items from the objects property table</p>
     */
-    public function chunk( $size, $preserve ) {}
+    public function chunk( $size, $preserve = false ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Returns the number of properties for this object
     * @link https://secure.php.net/manual/en/threaded.count.php
-     * @return int <p>Returns the number of properties for this object</p>
+     * @return int <p>The number of properties for this object</p>
     */
    public function count() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 3.0.0)<br/>
+     * Decrements the internal number of references to a Threaded object
+     * @return void
+     */
+    public function delRef() {}
+
+    /**
+     * (PECL pthreads &gt;= 2.0.8)<br/>
+     * Makes thread safe standard class at runtime
+     * @link https://secure.php.net/manual/en/threaded.extend.php
+     * @param string $class <p>The class to extend</p>
+     * @return bool <p>A boolean indication of success</p>
+     */
+    public static function extend( $class ) {}
+
+    /**
+     * (PECL pthreads &gt;= 3.0.0)<br/>
+     * Retrieves the internal number of references to a Threaded object
+     * @return int <p>The number of references to the Threaded object</p>
+     */
+    public function getRefCount() {}
+
+    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Retrieves terminal error information from the referenced object
     * @link https://secure.php.net/manual/en/threaded.getterminationinfo.php
     * @return array <p>array containing the termination conditions of the referenced object</p>
@ -198,67 +235,84 @@ class Threaded implements Traversable, Countable, ArrayAccess {
    public function getTerminationInfo() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Tell if the referenced object is executing
     * @link https://secure.php.net/manual/en/thread.isrunning.php
-     * @return boolean
+     * @return bool <p>A boolean indication of state</p>
     */
    public function isRunning() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 3.1.0)<br/>
+     * @inheritdoc
+     * @see Collectable::isGarbage()
+     */
+    public function isGarbage() {}
+
+    /**
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Tell if the referenced object was terminated during execution; suffered
     * fatal errors, or threw uncaught exceptions
     * @link https://secure.php.net/manual/en/threaded.isterminated.php
-     * @return boolean
+     * @return bool <p>A boolean indication of state</p>
     */
    public function isTerminated() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Tell if the referenced object is waiting for notification
     * @link https://secure.php.net/manual/en/threaded.iswaiting.php
-     * @return boolean <p>A boolean indication of state</p>
+     * @return bool <p>A boolean indication of state</p>
     */
    public function isWaiting() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Lock the referenced objects property table
-     * @link https://php.net/manual/en/threaded.lock.php
+     * @see Threaded::synchronized()
     * @link https://secure.php.net/manual/en/threaded.lock.php
-     * @return boolean
+     * @return bool <p>A boolean indication of success</p>
     */
    public function lock() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Merges data into the current object
     * @link https://secure.php.net/manual/en/threaded.merge.php
-     * @var mixed $from
-     * @var mixed $overwrite [optional]
-     * @return boolean
+     * @var mixed $from <p>The data to merge</p>
+     * @var bool $overwrite [optional] <p>Overwrite existing keys, by default true</p>
+     * @return bool <p>A boolean indication of success</p>
     */
-    public function merge( $from, $overwrite = null ) {}
+    public function merge( $from, $overwrite = true ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Send notification to the referenced object
     * @link https://secure.php.net/manual/en/threaded.notify.php
-     * @return boolean
+     * @return bool <p>A boolean indication of success</p>
     */
    public function notify() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 3.0.0)<br/>
+     * Send notification to the referenced object. This unblocks at least one
+     * of the blocked threads (as opposed to unblocking all of them, as seen with
+     * Threaded::notify()).
+     * @link https://secure.php.net/manual/en/threaded.notifyone.php
+     * @return bool <p>A boolean indication of success</p>
+     */
+    public function notifyOne() {}
+
+    /**
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Pops an item from the objects property table
     * @link https://secure.php.net/manual/en/threaded.pop.php
-     * @return boolean
+     * @return mixed <p>The last item from the objects property table</p>
     */
    public function pop() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * The programmer should always implement the run method for objects
     * that are intended for execution.
     * @link https://secure.php.net/manual/en/threaded.run.php
@ -267,105 +321,81 @@ class Threaded implements Traversable, Countable, ArrayAccess {
    public function run() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
+     * @inheritdoc
+     * @see Collectable::setGarbage()
+     */
+    public function setGarbage() {}
+
+    /**
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Shifts an item from the objects property table
     * @link https://secure.php.net/manual/en/threaded.shift.php
-     * @return boolean
+     * @return mixed <p>The first item from the objects property table</p>
     */
    public function shift() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Executes the block while retaining the referenced objects
     * synchronization lock for the calling context
     * @link https://secure.php.net/manual/en/threaded.synchronized.php
-     * @param Closure $block
-     * @param mixed $_ [optional]
-     * @return mixed
+     * @param Closure $block <p>The block of code to execute</p>
+     * @param mixed ...$_ [optional] <p>Variable length list of arguments
+     * to use as function arguments to the block</p>
+     * @return mixed <p>The return value from the block</p>
     */
-    public function synchronized( $block, $_ = null ) {}
+    public function synchronized( $block, ...$_ ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Unlock the referenced objects storage for the calling context
+     * @see Threaded::synchronized()
     * @link https://secure.php.net/manual/en/threaded.unlock.php
-     * @return boolean
+     * @return bool <p>A boolean indication of success</p>
     */
    public function unlock() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Will cause the calling context to wait for notification from the
     * referenced object
     * @link https://secure.php.net/manual/en/threaded.wait.php
-     * @param int $timeout [optional]
-     * @return boolean
+     * @param int $timeout [optional] <p>An optional timeout in microseconds</p>
+     * @return bool <p>A boolean indication of success</p>
     */
    public function wait( $timeout = 0 ) {}


    /**
-     * Whether a offset exists
-     * @link https://php.net/manual/en/arrayaccess.offsetexists.php
-     * @param mixed $offset <p>
-     * An offset to check for.
-     * </p>
-     * @return boolean true on success or false on failure.
-     * </p>
-     * <p>
-     * The return value will be casted to boolean if non-boolean was returned.
-     * @since 5.0.0
+     * @inheritdoc
+     * @see ArrayAccess::offsetExists()
     */
-    public function offsetExists($offset) {
-    }
+    public function offsetExists( $offset ) {}

    /**
-     * Offset to retrieve
-     * @link https://php.net/manual/en/arrayaccess.offsetget.php
-     * @param mixed $offset <p>
-     * The offset to retrieve.
-     * </p>
-     * @return mixed Can return all value types.
-     * @since 5.0.0
+     * @inheritdoc
+     * @see ArrayAccess::offsetGet()
     */
-    public function offsetGet($offset) {
-    }
+    public function offsetGet( $offset ) {}

    /**
-     * Offset to set
-     * @link https://php.net/manual/en/arrayaccess.offsetset.php
-     * @param mixed $offset <p>
-     * The offset to assign the value to.
-     * </p>
-     * @param mixed $value <p>
-     * The value to set.
-     * </p>
-     * @return void
-     * @since 5.0.0
+     * @inheritdoc
+     * @see ArrayAccess::offsetSet()
     */
-    public function offsetSet($offset, $value) {
-    }
+    public function offsetSet( $offset, $value ) {}

    /**
-     * Offset to unset
-     * @link https://php.net/manual/en/arrayaccess.offsetunset.php
-     * @param mixed $offset <p>
-     * The offset to unset.
-     * </p>
-     * @return void
-     * @since 5.0.0
+     * @inheritdoc
+     * @see ArrayAccess::offsetUnset()
     */
-    public function offsetUnset($offset) {
-    }
-
-
-
-
+    public function offsetUnset( $offset ) {}
 }

 /**
 * Stackable is an alias of Threaded. This class name was used in pthreads until
 * version 2.0.0
+ * @see Threaded
 * @link https://secure.php.net/manual/en/class.threaded.php
 */
 class Stackable extends Threaded implements Traversable, Countable, ArrayAccess {
@ -373,23 +403,25 @@ class Stackable extends Threaded implements Traversable, Countable, ArrayAccess
 }

 /**
- * When the start method of a Thread is invoked, the run method code will
- * be executed in separate Thread, asynchronously.<br/>After the run method
- * is executed the Thread will exit immediately, it will be joined with
- * the creating Thread at the approriate time.
+ * (PECL pthreads &gt;= 2.0.0)<br/>
+ * When the start method of a Thread is invoked, the run method code will be
+ * executed in separate Thread, in parallel.<br/>
+ * After the run method is executed the Thread will exit immediately, it will
+ * be joined with the creating Thread at the approriate time.
+ *
 * @link https://secure.php.net/manual/en/class.thread.php
 */
-class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
+class Thread extends Threaded implements Countable, Traversable, ArrayAccess {
    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Detaches the referenced Thread from the calling context, dangerously!
+     * (PECL pthreads &lt; 3.0.0)<br/>
+     * Detaches the referenced Thread from the calling context, dangerous!
     * @link https://secure.php.net/manual/en/thread.detach.php
     * @return void
     */
    public function detach() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Will return the identity of the Thread that created the referenced Thread
     * @link https://secure.php.net/manual/en/thread.getcreatorid.php
     * @return int <p>A numeric identity</p>
@ -397,7 +429,7 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
    public function getCreatorId() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Return a reference to the currently executing Thread
     * @link https://secure.php.net/manual/en/thread.getcurrentthread.php
     * @return Thread <p>An object representing the currently executing Thread</p>
@ -405,7 +437,7 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
    public static function getCurrentThread() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Will return the identity of the currently executing Thread
     * @link https://secure.php.net/manual/en/thread.getcurrentthreadid.php
     * @return int <p>A numeric identity</p>
@ -413,7 +445,7 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
    public static function getCurrentThreadId() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Will return the identity of the referenced Thread
     * @link https://secure.php.net/manual/en/thread.getthreadid.php
     * @return int <p>A numeric identity</p>
@ -421,7 +453,7 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
    public function getThreadId() {}

    /**
-     * (PECL pthreads &gt;= 2.0.1)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Will execute a Callable in the global scope
     * @link https://secure.php.net/manual/en/thread.globally.php
     * @return mixed <p>The return value of the Callable</p>
@ -429,31 +461,31 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
    public static function globally() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Tell if the referenced Thread has been joined
     * @link https://secure.php.net/manual/en/thread.isjoined.php
-     * @return boolean <p>A boolean indication of state</p>
+     * @return bool <p>A boolean indication of state</p>
     */
    public function isJoined() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Tell if the referenced Thread was started
     * @link https://secure.php.net/manual/en/thread.isstarted.php
-     * @return boolean <p>A boolean indication of state</p>
+     * @return bool <p>A boolean indication of state</p>
     */
    public function isStarted() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Causes the calling context to wait for the referenced Thread to finish executing
     * @link https://secure.php.net/manual/en/thread.join.php
-     * @return boolean <p>A boolean indication of success</p>
+     * @return bool <p>A boolean indication of success</p>
     */
    public function join() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Forces the referenced Thread to terminate
     * @link https://secure.php.net/manual/en/thread.kill.php
     * @return bool <p>A boolean indication of success</p>
@ -461,24 +493,25 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
    public function kill() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &gt;= 2.0.0)<br/>
     * Will start a new Thread to execute the implemented run method
     * @link https://secure.php.net/manual/en/thread.start.php
-     * @param integer $options [optional] An optional mask of inheritance constants, by default <b>PTHREADS_INHERIT_ALL</b>
-     * @return boolean <p>A boolean indication of success</p>
+     * @param int $options [optional] <p>An optional mask of inheritance
+     * constants, by default <b>{@link PTHREADS_INHERIT_ALL}</b></p>
+     * @return bool <p>A boolean indication of success</p>
     */
-    public function start( $options = 0 ) {}
-
+    public function start( $options = PTHREADS_INHERIT_ALL ) {}
 }

 /**
+ * (PECL pthreads &gt;= 2.0.0)<br/>
 * Worker Threads have a persistent context, as such should be used over
 * Threads in most cases.<br/>
 * When a Worker is started, the run method will be executed, but the Thread will
- * not leave until one of the following conditions are met:<br/>
- * - the Worker goes out of scope (no more references remain)<br/>
- * - the programmer calls shutdown<br/>
- * - the script dies<br/>
+ * not leave until one of the following conditions are met:<br/><ul>
+ * <li>the Worker goes out of scope (no more references remain)</li>
+ * <li>the programmer calls shutdown</li>
+ * <li>the script dies</li></ul>
 * This means the programmer can reuse the context throughout execution; placing
 * objects on the stack of the Worker will cause the Worker to execute the stacked
 * objects run method.
@ -486,105 +519,146 @@ class Thread extends Threaded implements Traversable, Countable, ArrayAccess {
 */
 class Worker extends Thread implements Traversable, Countable, ArrayAccess {
    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Returns the number of objects waiting to be executed by the referenced Worker
+     * (PECL pthreads &gt;= 3.0.0)<br/>
+     * Allows the worker to collect references determined to be garbage by the
+     * optionally given collector
+     * @link https://secure.php.net/manual/en/worker.collect.php
+     * @param callable $collector [optional] <p>A Callable collector that returns
+     * a boolean on whether the task can be collected or not. Only in rare cases
+     * should a custom collector need to be used</p>
+     * @return int <p>The number of remaining tasks on the worker's stack to be
+     * collected</p>
+     */
+    public function collect( $collector = null ) {}
+
+    /**
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Returns the number of tasks left on the stack
     * @link https://secure.php.net/manual/en/worker.getstacked.php
-     * @return int <p>An numeric value</p>
+     * @return int <p>Returns the number of tasks currently waiting to be
+     * executed by the worker</p>
     */
    public function getStacked() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Tell if the referenced Worker has been shutdown
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Whether the worker has been shutdown or not
     * @link https://secure.php.net/manual/en/worker.isshutdown.php
-     * @return boolean <p>A boolean indication of state</p>
+     * @return bool <p>Returns whether the worker has been shutdown or not</p>
     */
    public function isShutdown() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Tell if a Worker is executing Stackables
     * @link https://secure.php.net/manual/en/worker.isworking.php
-     * @return boolean <p>A boolean indication of state</p>
+     * @return bool <p>A boolean indication of state</p>
     */
    public function isWorking() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Shuts down the Worker after executing all the objects previously stacked
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Shuts down the Worker after executing all of the stacked tasks
     * @link https://secure.php.net/manual/en/worker.shutdown.php
-     * @return boolean
+     * @return bool <p>Whether the worker was successfully shutdown or not</p>
     */
    public function shutdown() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Appends the referenced object to the stack of the referenced Worker
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Appends the new work to the stack of the referenced worker
     * @link https://secure.php.net/manual/en/worker.stack.php
-     * @param Threaded $work <p>Threaded object to be executed by the referenced Worker</p>
-     * @return int <p>The new length of the stack</p>
+     * @param Threaded &$work <p>A Threaded object to be executed by the Worker</p>
+     * @return int <p>The new size of the stack</p>
     */
    public function stack( &$work ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
-     * Removes the referenced object ( or all objects if parameters are void )
-     * from stack of the referenced Worker
+     * (PECL pthreads &gt;= 2.0.0)<br/>
+     * Removes the first task (the oldest one) in the stack
     * @link https://secure.php.net/manual/en/worker.unstack.php
-     * @param Threaded $work [optional] <p>Threaded object previously stacked onto Worker</p>
-     * @return int <p>The new length of the stack</p>
+     * @return int <p>The new size of the stack</p>
     */
-    public function unstack( &$work = null ) {}
-
+    public function unstack() {}
 }

 /**
+ * (PECL pthreads &gt;= 2.0.8)<br/>
+ * Represents a garbage-collectable object.
+ * @link https://secure.php.net/manual/en/class.collectable.php
+ */
+interface Collectable {
+    /**
+     * (PECL pthreads &gt;= 2.0.8)<br/>
+     * Can be called in {@link Pool::collect()} to determine if this object is garbage
+     * @link https://secure.php.net/manual/en/collectable.isgarbage.php
+     * @return bool <p>Whether this object is garbage or not</p>
+     */
+    public function isGarbage();
+
+    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
+     * Should be called once per object when the object is finished being
+     * executed or referenced
+     * @link https://secure.php.net/manual/en/collectable.setgarbage.php
+     * @return void
+     */
+    public function setGarbage();
+}
+
+/**
+ * (PECL pthreads &lt; 3.0.0)<br>
 * The static methods contained in the Mutex class provide direct access to Posix
 * Mutex functionality.
 * @link https://secure.php.net/manual/en/class.mutex.php
 */
 class Mutex {
    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Create, and optionally lock a new Mutex for the caller
     * @link https://secure.php.net/manual/en/mutex.create.php
-     * @param boolean $lock [optional] <p>Setting lock to true will lock the Mutex for the caller before returning the handle</p>
+     * @param bool $lock [optional] <p>Setting lock to true will lock the Mutex for the caller before returning the handle</p>
     * @return int <p>A newly created and optionally locked Mutex handle</p>
     */
    final public static function create ( $lock = false ) {}

    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Destroying Mutex handles must be carried out explicitly by the programmer when
     * they are finished with the Mutex handle.
     * @link https://secure.php.net/manual/en/mutex.destroy.php
     * @param int $mutex <p>A handle returned by a previous call to
     * {@see Mutex::create()}. The handle should not be locked by any Thread when
     * {@see Mutex::destroy()} is called.</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function destroy( $mutex ) {}

    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Attempt to lock the Mutex for the caller.<br/>
     * An attempt to lock a Mutex owned (locked) by another Thread will result in
     * blocking.
     * @link https://secure.php.net/manual/en/mutex.lock.php
     * @param int $mutex <p>A handle returned by a previous call to
     * {@see Mutex::create()}.</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function lock( $mutex ) {}

    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Attempt to lock the Mutex for the caller without blocking if the Mutex is
     * owned (locked) by another Thread.
     * @link https://secure.php.net/manual/en/mutex.trylock.php
     * @param int $mutex int $mutex <p>A handle returned by a previous call to
     * {@see Mutex::create()}.</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function trylock( $mutex ) {}

    /**
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Attempts to unlock the Mutex for the caller, optionally destroying the Mutex
     * handle. The calling thread should own the Mutex at the time of the call.
     * @link https://secure.php.net/manual/en/mutex.unlock.php
@ -592,29 +666,30 @@ class Mutex {
     * {@see Mutex::create()}.</p>
     * @param bool $destroy [optional]
     * <p>When true pthreads will destroy the Mutex after a successful unlock.</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function unlock( $mutex, $destroy = false ) {}
 }

 /**
+ * (PECL pthreads &lt; 3.0.0)<br/>
 * The static methods contained in the Cond class provide direct access to Posix
 * Condition Variables.
 * @link https://secure.php.net/manual/en/class.cond.php
 */
 class Cond {
    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Broadcast to all Threads blocking on a call to Cond::wait().
     * @link https://secure.php.net/manual/en/cond.broadcast.php
     * @param int $condition <p>A handle to a Condition Variable returned by a previous call to
     * {@see Cond::create()}</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function broadcast( $condition ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Creates a new Condition Variable for the caller.
     * @link https://secure.php.net/manual/en/cond.create.php
     * @return int <p>A handle to a Condition Variable</p>
@ -622,29 +697,29 @@ class Cond {
    final public static function create() {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Destroying Condition Variable handles must be carried out explicitly by the
     * programmer when they are finished with the Condition Variable. No Threads should
     * be blocking on a call to Cond::wait() when the call to Cond::destroy() takes place.
     * @link https://secure.php.net/manual/en/cond.destroy.php
     * @param int $condition <p>A handle to a Condition Variable returned by a previous call to
     * {@see Cond::create()}</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function destroy( $condition ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * A handle returned by a previous call to Cond::create()
     * @link https://secure.php.net/manual/en/cond.signal.php
     * @param int $condition <p>A handle to a Condition Variable returned by a previous call to
     * {@see Cond::create()}</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function signal( $condition ) {}

    /**
-     * (PECL pthreads &gt;= 2.0.0)
+     * (PECL pthreads &lt; 3.0.0)<br/>
     * Wait for a signal on a Condition Variable, optionally specifying a timeout to
     * limit waiting time.
     * @link https://secure.php.net/manual/en/cond.wait.php
@ -653,7 +728,21 @@ class Cond {
     * @param int $mutex <p>A handle returned by a previous call to
     * {@see Mutex::create()} and owned (locked) by the caller.</p>
     * @param int $timeout [optional] <p>An optional timeout, in microseconds ( millionths of a second ).</p>
-     * @return boolean <p>A boolean indication of success.</p>
+     * @return bool <p>A boolean indication of success.</p>
     */
    final public static function wait( $condition, $mutex, $timeout = 0 ) {}
 }
+
+/**
+ * (PECL pthreads &gt;= 3.0.0)<br/>
+ * The Volatile class is new to pthreads v3. Its introduction is a consequence of
+ * the new immutability semantics of Threaded members of Threaded classes. The
+ * Volatile class enables for mutability of its Threaded members, and is also
+ * used to store PHP arrays in Threaded contexts.
+ * @see Threaded
+ * @link https://secure.php.net/manual/en/class.volatile.php
+ */
+class Volatile extends Threaded implements Collectable, Traversable
+    {
+
+    }