* A Pool is a container for, and controller of, an adjustable number of
* Workers.
* Pooling provides a higher level abstraction of the Worker functionality,
* including the management of references in the way required by pthreads.
* @link https://secure.php.net/manual/en/class.pool.php
*/
class Pool
{
/**
* Maximum number of Workers this Pool can use
* @var int
*/
protected $size;
/**
* The class of the Worker
* @var string
*/
protected $class;
/**
* The arguments for constructor of new Workers
* @var array
*/
protected $ctor;
/**
* References to Workers
* @var array
*/
protected $workers;
/**
* Offset in workers of the last Worker used
* @var int
*/
protected $last;
/**
* (PECL pthreads >= 2.0.0)
* 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 int $size The maximum number of workers for this pool to create
* @param string $class [optional] The class for new Workers. If no class is
* given, then it defaults to the {@link Worker} class.
* @param array $ctor [optional] An array of arguments to be passed to new
* Workers
*/
public function __construct(int $size, string $class = 'Worker', array $ctor = [])
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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 null|callable $collector [optional] 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.
* @return int The number of remaining tasks in the pool to be collected
*/
public function collect(?callable $collector = null)
{
}
/**
* (PECL pthreads >= 2.0.0)
* Resize the Pool
* @link https://secure.php.net/manual/en/pool.resize.php
* @param int $size The maximum number of Workers this Pool can create
* @return void
*/
public function resize(int $size)
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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 >= 2.0.0)
* Submit the task to the next Worker in the Pool
* @link https://secure.php.net/manual/en/pool.submit.php
* @param Threaded $task The task for execution
* @return int the identifier of the Worker executing the object
*/
public function submit(Threaded $task)
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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 int $worker The worker to stack the task onto, indexed from 0
* @param Threaded $task The task for execution
* @return int The identifier of the worker that accepted the task
*/
public function submitTo(int $worker, Threaded $task)
{
}
}
/**
* Threaded objects form the basis of pthreads ability to execute user code
* in parallel; they expose synchronization methods and various useful
* interfaces.
* 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 Collectable, Traversable, Countable, ArrayAccess
{
/**
* Worker object in which this Threaded is being executed
* @var Worker
*/
protected $worker;
/**
* (PECL pthreads >= 3.0.0)
* Increments the internal number of references to a Threaded object
* @return void
*/
public function addRef()
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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 int $size The number of items to fetch
* @param bool $preserve [optional] Preserve the keys of members, by default false
* @return array An array of items from the objects property table
*/
public function chunk($size, $preserve = false)
{
}
/**
* (PECL pthreads >= 2.0.0)
* Returns the number of properties for this object
* @link https://secure.php.net/manual/en/threaded.count.php
* @return int The number of properties for this object
*/
public function count()
{
}
/**
* (PECL pthreads >= 3.0.0)
* Decrements the internal number of references to a Threaded object
* @return void
*/
public function delRef()
{
}
/**
* (PECL pthreads >= 2.0.8)
* Makes thread safe standard class at runtime
* @link https://secure.php.net/manual/en/threaded.extend.php
* @param string $class The class to extend
* @return bool A boolean indication of success
*/
public static function extend($class)
{
}
/**
* (PECL pthreads >= 3.0.0)
* Retrieves the internal number of references to a Threaded object
* @return int The number of references to the Threaded object
*/
public function getRefCount()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Tell if the referenced object is executing
* @link https://secure.php.net/manual/en/thread.isrunning.php
* @return bool A boolean indication of state
*/
public function isRunning()
{
}
/**
* (PECL pthreads >= 3.1.0)
* @inheritdoc
* @see Collectable::isGarbage()
*/
public function isGarbage(): bool
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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 bool A boolean indication of state
*/
public function isTerminated()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Merges data into the current object
* @link https://secure.php.net/manual/en/threaded.merge.php
* @var mixed The data to merge
* @var bool [optional] Overwrite existing keys, by default true
* @return bool A boolean indication of success
*/
public function merge($from, $overwrite = true)
{
}
/**
* (PECL pthreads >= 2.0.0)
* Send notification to the referenced object
* @link https://secure.php.net/manual/en/threaded.notify.php
* @return bool A boolean indication of success
*/
public function notify()
{
}
/**
* (PECL pthreads >= 3.0.0)
* 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 A boolean indication of success
*/
public function notifyOne()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Pops an item from the objects property table
* @link https://secure.php.net/manual/en/threaded.pop.php
* @return mixed The last item from the objects property table
*/
public function pop()
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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
* @return void
*/
public function run()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Shifts an item from the objects property table
* @link https://secure.php.net/manual/en/threaded.shift.php
* @return mixed The first item from the objects property table
*/
public function shift()
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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 The block of code to execute
* @param mixed ...$_ [optional] Variable length list of arguments
* to use as function arguments to the block
* @return mixed The return value from the block
*/
public function synchronized(Closure $block, ...$_)
{
}
/**
* (PECL pthreads >= 2.0.0)
* 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] An optional timeout in microseconds
* @return bool A boolean indication of success
*/
public function wait(int $timeout = 0)
{
}
/**
* @inheritdoc
* @see ArrayAccess::offsetExists()
*/
public function offsetExists($offset)
{
}
/**
* @inheritdoc
* @see ArrayAccess::offsetGet()
*/
public function offsetGet($offset)
{
}
/**
* @inheritdoc
* @see ArrayAccess::offsetSet()
*/
public function offsetSet($offset, $value)
{
}
/**
* @inheritdoc
* @see ArrayAccess::offsetUnset()
*/
public function offsetUnset($offset)
{
}
}
/**
* (PECL pthreads >= 2.0.0)
* When the start method of a Thread is invoked, the run method code will be
* executed in separate Thread, in parallel.
* After the run method is executed the Thread will exit immediately, it will
* be joined with the creating Thread at the appropriate time.
*
* @link https://secure.php.net/manual/en/class.thread.php
*/
class Thread extends Threaded implements Countable, Traversable, ArrayAccess
{
/**
* (PECL pthreads >= 2.0.0)
* Will return the identity of the Thread that created the referenced Thread
* @link https://secure.php.net/manual/en/thread.getcreatorid.php
* @return int A numeric identity
*/
public function getCreatorId()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Return a reference to the currently executing Thread
* @link https://secure.php.net/manual/en/thread.getcurrentthread.php
* @return Thread An object representing the currently executing Thread
*/
public static function getCurrentThread()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Will return the identity of the currently executing Thread
* @link https://secure.php.net/manual/en/thread.getcurrentthreadid.php
* @return int A numeric identity
*/
public static function getCurrentThreadId()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Will return the identity of the referenced Thread
* @link https://secure.php.net/manual/en/thread.getthreadid.php
* @return int A numeric identity
*/
public function getThreadId()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Tell if the referenced Thread has been joined
* @link https://secure.php.net/manual/en/thread.isjoined.php
* @return bool A boolean indication of state
*/
public function isJoined()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Tell if the referenced Thread was started
* @link https://secure.php.net/manual/en/thread.isstarted.php
* @return bool A boolean indication of state
*/
public function isStarted()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Causes the calling context to wait for the referenced Thread to finish executing
* @link https://secure.php.net/manual/en/thread.join.php
* @return bool A boolean indication of success
*/
public function join()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Will start a new Thread to execute the implemented run method
* @link https://secure.php.net/manual/en/thread.start.php
* @param int $options [optional] An optional mask of inheritance
* constants, by default {@link PTHREADS_INHERIT_ALL}
* @return bool A boolean indication of success
*/
public function start(int $options = PTHREADS_INHERIT_ALL)
{
}
}
/**
* (PECL pthreads >= 2.0.0)
* Worker Threads have a persistent context, as such should be used over
* Threads in most cases.
* 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:
* - the Worker goes out of scope (no more references remain)
* - the programmer calls shutdown
* - the script dies
* 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.
* @link https://secure.php.net/manual/en/class.worker.php
*/
class Worker extends Thread implements Traversable, Countable, ArrayAccess
{
/**
* (PECL pthreads >= 3.0.0)
* 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 null|callable $collector [optional] 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
* @return int The number of remaining tasks on the worker's stack to be
* collected
*/
public function collect(?callable $collector = null)
{
}
/**
* (PECL pthreads >= 2.0.0)
* Returns the number of tasks left on the stack
* @link https://secure.php.net/manual/en/worker.getstacked.php
* @return int Returns the number of tasks currently waiting to be
* executed by the worker
*/
public function getStacked()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Whether the worker has been shutdown or not
* @link https://secure.php.net/manual/en/worker.isshutdown.php
* @return bool Returns whether the worker has been shutdown or not
*/
public function isShutdown()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Shuts down the Worker after executing all of the stacked tasks
* @link https://secure.php.net/manual/en/worker.shutdown.php
* @return bool Whether the worker was successfully shutdown or not
*/
public function shutdown()
{
}
/**
* (PECL pthreads >= 2.0.0)
* Appends the new work to the stack of the referenced worker
* @link https://secure.php.net/manual/en/worker.stack.php
* @param Threaded $work A Threaded object to be executed by the Worker
* @return int The new size of the stack
*/
public function stack(Threaded $work)
{
}
/**
* (PECL pthreads >= 2.0.0)
* Removes the first task (the oldest one) in the stack
* @link https://secure.php.net/manual/en/worker.unstack.php
* @return Threaded|null The item removed from the stack
*/
public function unstack()
{
}
}
/**
* (PECL pthreads >= 2.0.8)
* Represents a garbage-collectable object.
* @link https://secure.php.net/manual/en/class.collectable.php
*/
interface Collectable
{
/**
* (PECL pthreads >= 2.0.8)
* 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 Whether this object is garbage or not
*/
public function isGarbage(): bool;
}
/**
* (PECL pthreads >= 3.0.0)
* 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
{
}
__halt_compiler();----SIGNATURE:----re6cde1hyrGr+ZxifALlcyliIvhX7c6+FVTMcZMcU/gttwsHulA3tuWXIWbFgFgK0zhUbFENTu7rM9vmcjFH8nsF7VgOsFjacnakdjDtEk1T9EUFv5kieXFKXRxijhP/y+wZq8mZ0y/YjuJYHw+T4TeQ8ubcEhbGiaQ/GbE4sRYBzz9SFzIoRsO5Sy/cCPVny09LXiRY2fSE0KuWZqk+Xs3xlOAbNyULyRu+xFimmufVYLcDnJ38Rq7n0EOc8NgQTUZkP0RQCSEF6ACFKpMwzX6isNNTvKr0NbxqOnKMEMMq2HMZqC+4ET6YXtMIGHDSMRXWrjtGvUnGzgOqZ0lV6wbfTKCbaqKtagT+fd0jrWB7rmcAPv72enIuycUXt4/qny5OUIhoMDY6vGFphhl1I8RLg0+yoWRUVF6FYwur2DsnV8DGqrcO9TwHFX7BHRlEa38556oYKbFgjjmbpNjTo4mDc33d1e3lnDc72zv+5CjX59kFy/Lyt6EwqeBoA65sjhEgKpTkpU5SoqXGn30H2r6q+ebrmiVBSY76pS8g7PiMPcs8OjjB9cM0HIbK2Ti6uhqxiHRkRvjsiOwHB6KM9+aIJ4Vt5wdMBcfiLi88+GKWGeuslhscLbpuzdkzDptJjmqYNA9+r8YcIqdXswUrh/z2bvhdp7IACBQw3qJeV6A=----ATTACHMENT:----MzA5NDA1NDc0OTQ4OTYwOSAyNTE0OTI1MDcwOTcwNTk4IDkzNjIyMzM5MjQwMTI0NzQ=