1
0
mirror of https://github.com/danog/parallel.git synced 2024-12-03 10:07:49 +01:00
parallel/lib/Threading/Internal/Thread.php

152 lines
4.6 KiB
PHP
Raw Normal View History

2016-12-30 02:16:04 +01:00
<?php
2016-08-23 23:47:40 +02:00
namespace Amp\Parallel\Threading\Internal;
2016-08-18 18:04:48 +02:00
2017-05-18 09:51:31 +02:00
use Amp\Loop;
use Amp\Parallel\Sync\Channel;
use Amp\Parallel\Sync\ChannelException;
use Amp\Parallel\Sync\ChannelledSocket;
use Amp\Parallel\Sync\Internal\ExitFailure;
use Amp\Parallel\Sync\Internal\ExitSuccess;
use Amp\Parallel\Sync\SerializationException;
2017-07-19 06:44:25 +02:00
use function Amp\call;
/**
* An internal thread that executes a given function concurrently.
*
* @internal
*/
2016-08-18 18:04:48 +02:00
class Thread extends \Thread {
const KILL_CHECK_FREQUENCY = 250;
/** @var string */
private static $autoloadPath;
2016-08-26 17:10:03 +02:00
/** @var callable The function to execute in the thread. */
private $function;
2016-08-26 17:10:03 +02:00
/** @var mixed[] Arguments to pass to the function. */
private $args;
2016-08-26 17:10:03 +02:00
/** @var resource */
private $socket;
2016-08-26 17:10:03 +02:00
/** @var bool */
private $killed = false;
/**
* Creates a new thread object.
*
* @param resource $socket IPC communication socket.
* @param callable $function The function to execute in the thread.
* @param mixed[] $args Arguments to pass to the function.
*/
2016-08-18 18:04:48 +02:00
public function __construct($socket, callable $function, array $args = []) {
$this->function = $function;
$this->args = $args;
$this->socket = $socket;
if (self::$autoloadPath === null) { // Determine path to composer autoload.php
2017-01-17 12:14:06 +01:00
$files = [
2017-01-17 16:46:30 +01:00
dirname(__DIR__, 3) . \DIRECTORY_SEPARATOR . "vendor" . \DIRECTORY_SEPARATOR . "autoload.php",
dirname(__DIR__, 5) . \DIRECTORY_SEPARATOR . "autoload.php",
2017-01-17 12:14:06 +01:00
];
foreach ($files as $file) {
2017-01-17 18:53:42 +01:00
if (in_array($file, \get_included_files())) {
2017-01-17 16:46:30 +01:00
self::$autoloadPath = $file;
return;
}
}
2017-01-17 16:46:30 +01:00
throw new \Error("Could not locate autoload.php");
}
}
/**
* Runs the thread code and the initialized function.
*
* @codeCoverageIgnore Only executed in thread.
*/
2016-08-18 18:04:48 +02:00
public function run() {
/* First thing we need to do is re-initialize the class autoloader. If
* we don't do this first, any object of a class that was loaded after
* the thread started will just be garbage data and unserializable
* values (like resources) will be lost. This happens even with
* thread-safe objects.
*/
// Protect scope by using an unbound closure (protects static access as well).
$autoloadPath = self::$autoloadPath;
(static function () use ($autoloadPath) { require $autoloadPath; })->bindTo(null, null)();
// At this point, the thread environment has been prepared so begin using the thread.
try {
Loop::run(function () {
2016-08-31 01:27:14 +02:00
$channel = new ChannelledSocket($this->socket, $this->socket, false);
$watcher = Loop::repeat(self::KILL_CHECK_FREQUENCY, function () {
2016-08-18 18:04:48 +02:00
if ($this->killed) {
Loop::stop();
2016-08-18 18:04:48 +02:00
}
});
Loop::unreference($watcher);
return $this->execute($channel);
});
2016-01-27 08:03:37 +01:00
} catch (\Throwable $exception) {
2016-08-18 18:04:48 +02:00
return 1;
}
2016-08-18 18:04:48 +02:00
return 0;
}
/**
* Sets a local variable to true so the running event loop can check for a kill signal.
*/
2016-08-18 18:04:48 +02:00
public function kill() {
return $this->killed = true;
}
/**
* @coroutine
*
2016-08-23 23:47:40 +02:00
* @param \Amp\Parallel\Sync\Channel $channel
*
* @return \Generator
*
* @codeCoverageIgnore Only executed in thread.
*/
2016-08-18 18:04:48 +02:00
private function execute(Channel $channel): \Generator {
try {
2015-08-27 21:49:41 +02:00
if ($this->function instanceof \Closure) {
2017-07-19 06:44:25 +02:00
$result = call($this->function->bindTo($channel, Channel::class), ...$this->args);
} else {
$result = call($this->function, ...$this->args);
2015-08-27 21:49:41 +02:00
}
2017-07-19 06:44:25 +02:00
$result = new ExitSuccess(yield $result);
2016-01-23 07:00:56 +01:00
} catch (\Throwable $exception) {
$result = new ExitFailure($exception);
}
2017-07-19 06:44:25 +02:00
if ($this->killed) {
return; // Parent is not listening for a result.
}
2015-12-12 07:34:41 +01:00
// Attempt to return the result.
try {
2016-01-23 18:20:58 +01:00
try {
2017-07-19 06:44:25 +02:00
yield $channel->send($result);
2016-01-23 18:20:58 +01:00
} catch (SerializationException $exception) {
// Serializing the result failed. Send the reason why.
2017-07-19 06:44:25 +02:00
yield $channel->send(new ExitFailure($exception));
2016-01-23 18:20:58 +01:00
}
} catch (ChannelException $exception) {
// The result was not sendable! The parent context must have died or killed the context.
2015-12-12 07:34:41 +01:00
}
}
}