ByJG\PHPThread\Handler\PThreadHandler

Complexity

Total Complexity

18

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	6
Bugs	1	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getLoader()	0	17	4
A	threadError()	0	4	1
A	run()	0	8	1
A	execute()	0	5	1
A	getResult()	0	14	4
A	stop()	0	4	1
A	isAlive()	0	12	3
A	setCallable()	0	4	1
A	waitFinish()	0	4	1

<?php

namespace ByJG\PHPThread\Handler;

use Composer\Autoload\ClassLoader;

class PThreadHandler extends \Thread implements ThreadInterface
{
    /**
     * @var ClassLoader
     */
    private $loader;

    /**
     * @var callable
     */
    private $callable;

    private $args;

    private $result;

    private $hasError;

    /**
     * Thread constructor.
     */
    public function __construct()
    {
        $this->getLoader();
    }

    /**
     * @return ClassLoader
     */
    public function getLoader()
    {
        if (!is_null($this->loader)) {
            return $this->loader;
        }

        $path = __DIR__ . '/../../vendor/autoload.php';
        if (!file_exists($path)) {
            $path = __DIR__ . '/../../../../autoload.php';
            if (!file_exists($path)) {
                throw new \RuntimeException("Autoload path '$path' not found");
            }
        }
        $this->loader = require("$path");

        return $this->loader;
    }

    protected function threadError()
    {
        $this->hasError = error_get_last();
    }

    /**
     * Here you are in a threaded environment
     */
    public function run()
    {
        register_shutdown_function([$this, 'threadError']);

        $this->getLoader()->register();

        $this->result = call_user_func_array($this->callable, $this->args);
    }

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

It seems like you call parent on a different method (start() instead of execute()). Are you sure this is correct? If so, you might want to change this to $this->start().

    }

    /**
     * Get the thread result
     *
     * @return mixed
     * @throws \RuntimeException
     */
    public function getResult()
    {
        if ($this->hasError && ( $this->hasError['type'] == E_ERROR || $this->hasError['type'] == E_USER_ERROR )) {

The expression $this->hasError of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw new \RuntimeException(
                sprintf(
                    'Thread error: "%s", in "%s" at line %d. <<--- ',
                    $this->hasError['message'],
                    $this->hasError['file'],
                    $this->hasError['line']
                )
            );
        }
        return $this->result;
    }

    /**
     * Kill a thread
     *
     * @param int $signal
     * @param bool $wait
     */
    public function stop($signal = SIGKILL, $wait = false)
    {
        parent::kill();

It seems like you call parent on a different method (kill() instead of stop()). Are you sure this is correct? If so, you might want to change this to $this->kill().

    }

    /**
     * Checkif the thread is not Terminated
     *
     * @return bool
     */
    public function isAlive()
    {
        if ($this->isRunning()) {
            return true;
        }

        if (!$this->isJoined()) {
            $this->join();
        }

        return false;
    }

    /**
     * Set the thread callable method
     * @param callable $callable
     * @return mixed
     */
    public function setCallable(callable $callable)
    {
        $this->callable = $callable;
    }

    public function waitFinish()
    {
        $this->join();
    }
}