AliceMajere / wonderland-thread

src/Mediator/Event/EventInterface.php

Indentation +4 added lines, -4 removed lines

@@ -5,9 +5,9 @@
 interface EventInterface
 {
 
-	/**
-	 * @return string
-	 */
-	public function getEventName(): string;
+    /**
+     * @return string
+     */
+    public function getEventName(): string;
 
 }

src/Exception/ThreadException.php

Spacing +1 added lines, -1 removed lines

@@ -2,5 +2,5 @@
 
 namespace Wonderland\Thread\Exception;
 
-class ThreadException extends \Exception{
+class ThreadException extends \Exception {
 }

tests/unit/ThreadTest.php

Spacing +2 added lines, -2 removed lines

@@ -20,7 +20,7 @@ 
 
 	public function setUp()
 	{
-		$this->callback = function (){ return 0;
+		$this->callback = function() { return 0;
 
   };
 
@@ -46,7 +46,7 @@ 
 
 	public function test_callback()
 	{
-		$callback = function(){ return 1;
+		$callback = function() { return 1;
 
   };
 

Indentation +73 added lines, -73 removed lines

@@ -13,78 +13,78 @@
  */
 class ThreadTest extends TestCase
 {
-	/** @var AbstractThread */
-	private $thread;
-
-	private $callback;
-
-	public function setUp()
-	{
-		$this->callback = function (){ return 0;
-
-  };
-
-		$this->thread = new AbstractThread();
-		$this->thread->setPid(1);
-		$this->thread->setProcessName('unit-test');
-		$this->thread->setCallback($this->callback);
-	}
-
-	public function test_pid()
-	{
-		$this->assertSame(1, $this->thread->getPid());
-		$this->assertSame($this->thread, $this->thread->setPid(100));
-		$this->assertSame(100, $this->thread->getPid());
-	}
-
-	public function test_processName()
-	{
-		$this->assertSame('unit-test', $this->thread->getProcessName());
-		$this->assertSame($this->thread, $this->thread->setProcessName('unit'));
-		$this->assertSame('unit', $this->thread->getProcessName());
-	}
-
-	public function test_callback()
-	{
-		$callback = function(){ return 1;
-
-  };
-
-		$this->assertSame($this->callback, $this->thread->getCallback());
-		$this->assertSame($this->thread, $this->thread->setCallback($callback));
-		$this->assertSame($callback, $this->thread->getCallback());
-	}
-
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run()
-	{
-		$this->assertSame(0, $this->thread->run('unit-test'));
-	}
-
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run_exception()
-	{
-		$this->expectException(ThreadException::class);
-		$thread = new AbstractThread();
-		$thread->run('unit-test');
-
-	}
-
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run_exception_status()
-	{
-		$this->expectException(ThreadException::class);
-		$thread = new AbstractThread();
-		$thread->setCallback(function() { return null;
-
-  });
-		$thread->run('unit-test');
-	}
+    /** @var AbstractThread */
+    private $thread;
+
+    private $callback;
+
+    public function setUp()
+    {
+        $this->callback = function (){ return 0;
+
+    };
+
+        $this->thread = new AbstractThread();
+        $this->thread->setPid(1);
+        $this->thread->setProcessName('unit-test');
+        $this->thread->setCallback($this->callback);
+    }
+
+    public function test_pid()
+    {
+        $this->assertSame(1, $this->thread->getPid());
+        $this->assertSame($this->thread, $this->thread->setPid(100));
+        $this->assertSame(100, $this->thread->getPid());
+    }
+
+    public function test_processName()
+    {
+        $this->assertSame('unit-test', $this->thread->getProcessName());
+        $this->assertSame($this->thread, $this->thread->setProcessName('unit'));
+        $this->assertSame('unit', $this->thread->getProcessName());
+    }
+
+    public function test_callback()
+    {
+        $callback = function(){ return 1;
+
+    };
+
+        $this->assertSame($this->callback, $this->thread->getCallback());
+        $this->assertSame($this->thread, $this->thread->setCallback($callback));
+        $this->assertSame($callback, $this->thread->getCallback());
+    }
+
+    /**
+     * @throws ThreadException
+     */
+    public function test_run()
+    {
+        $this->assertSame(0, $this->thread->run('unit-test'));
+    }
+
+    /**
+     * @throws ThreadException
+     */
+    public function test_run_exception()
+    {
+        $this->expectException(ThreadException::class);
+        $thread = new AbstractThread();
+        $thread->run('unit-test');
+
+    }
+
+    /**
+     * @throws ThreadException
+     */
+    public function test_run_exception_status()
+    {
+        $this->expectException(ThreadException::class);
+        $thread = new AbstractThread();
+        $thread->setCallback(function() { return null;
+
+    });
+        $thread->run('unit-test');
+    }
 
 }

tests/bootstrap.php

Indentation +2 added lines, -2 removed lines

@@ -2,7 +2,7 @@ 
 declare( strict_types = 1 );
 
 if ( PHP_SAPI !== 'cli' ) {
-	die( 'Not an entry point' );
+    die( 'Not an entry point' );
 }
 
 error_reporting( -1 );
@@ -10,7 +10,7 @@ 
 ini_set( 'display_errors', '1' );
 
 if ( !is_readable( __DIR__ . '/../vendor/autoload.php' ) ) {
-	die( 'You need to install this package with Composer before you can run the tests' );
+    die( 'You need to install this package with Composer before you can run the tests' );
 }
 
 require_once __DIR__ . '/../vendor/autoload.php';

Spacing +6 added lines, -6 removed lines

@@ -1,16 +1,16 @@
 <?php
-declare( strict_types = 1 );
+declare(strict_types=1);
 
-if ( PHP_SAPI !== 'cli' ) {
-	die( 'Not an entry point' );
+if (PHP_SAPI !== 'cli') {
+	die('Not an entry point');
 }
 
 error_reporting( -1 );
 
-ini_set( 'display_errors', '1' );
+ini_set('display_errors', '1');
 
-if ( !is_readable( __DIR__ . '/../vendor/autoload.php' ) ) {
-	die( 'You need to install this package with Composer before you can run the tests' );
+if (!is_readable(__DIR__ . '/../vendor/autoload.php')) {
+	die('You need to install this package with Composer before you can run the tests');
 }
 
 require_once __DIR__ . '/../vendor/autoload.php';

src/Mediator/Mediator.php

Indentation +40 added lines, -40 removed lines

@@ -7,49 +7,49 @@
 
 class Mediator
 {
-	/** @var ListenerInterface[] */
-	private $listeners = [];
-
-	/**
-	 * @return ListenerInterface[]
-	 */
-	public function getListeners(): array
-	{
-		return $this->listeners;
-	}
-
-	/**
-	 * @param ListenerInterface $listener
-	 * @return Mediator
-	 */
-	public function addListener(ListenerInterface $listener): self
-	{
-		$this->listeners[] = $listener;
-
-		return $this;
-	}
-
-	/**
-	 * @param ListenerInterface $listener
-	 * @return Mediator
-	 */
-	public function removeListener(ListenerInterface $listener): self
-	{
+    /** @var ListenerInterface[] */
+    private $listeners = [];
+
+    /**
+     * @return ListenerInterface[]
+     */
+    public function getListeners(): array
+    {
+        return $this->listeners;
+    }
+
+    /**
+     * @param ListenerInterface $listener
+     * @return Mediator
+     */
+    public function addListener(ListenerInterface $listener): self
+    {
+        $this->listeners[] = $listener;
+
+        return $this;
+    }
+
+    /**
+     * @param ListenerInterface $listener
+     * @return Mediator
+     */
+    public function removeListener(ListenerInterface $listener): self
+    {
         if (false !== ($key = array_search($listener, $this->listeners, true))) {
             unset($this->listeners[$key]);
         }
 
-		return $this;
-	}
-
-	/**
-	 * @param EventInterface $event
-	 */
-	public function notify(EventInterface $event)
-	{
-		foreach ($this->listeners as $listener) {
-			$listener->notify($event);
-		}
-	}
+        return $this;
+    }
+
+    /**
+     * @param EventInterface $event
+     */
+    public function notify(EventInterface $event)
+    {
+        foreach ($this->listeners as $listener) {
+            $listener->notify($event);
+        }
+    }
 
 }

src/Mediator/Listener/AbstractListener.php

Indentation +6 added lines, -6 removed lines

@@ -9,16 +9,16 @@
     /**
      * @param EventInterface $event
      */
-	public function notify(EventInterface $event)
-	{
-	    $mapping = $this->getEventMapping();
-	    if (false === isset($mapping[$event->getEventName()])) {
-	        return;
+    public function notify(EventInterface $event)
+    {
+        $mapping = $this->getEventMapping();
+        if (false === isset($mapping[$event->getEventName()])) {
+            return;
         }
 
         call_user_func(
             [$this, $mapping[$event->getEventName()]],
             $event
         );
-	}
+    }
 }

src/Mediator/Listener/ListenerInterface.php

Indentation +9 added lines, -9 removed lines

@@ -6,15 +6,15 @@
 
 interface ListenerInterface
 {
-	/**
-	 * @return array
-	 */
-	public function getEventMapping(): array;
+    /**
+     * @return array
+     */
+    public function getEventMapping(): array;
 
-	/**
-	 * @param EventInterface $event
-	 * @return void
-	 */
-	public function notify(EventInterface $event);
+    /**
+     * @param EventInterface $event
+     * @return void
+     */
+    public function notify(EventInterface $event);
 
 }

src/AbstractThreadPoolMediator.php

Indentation +49 added lines, -49 removed lines

@@ -8,54 +8,54 @@
 
 abstract class AbstractThreadPoolMediator
 {
-	/** @var Mediator */
-	private $mediator;
-
-	/**
-	 * @return Mediator
-	 */
-	protected function getMediator()
-	{
-		return $this->mediator;
-	}
-
-	/**
-	 * ThreadPoolMediator constructor.
-	 */
-	public function __construct()
-	{
-		$this->mediator = new Mediator();
-	}
-
-	/**
-	 * @param ListenerInterface $listener
-	 * @return AbstractThreadPoolMediator
-	 */
-	public function addListener(ListenerInterface $listener): self
-	{
-		$this->mediator->addListener($listener);
-
-		return $this;
-	}
-
-	/**
-	 * @param ListenerInterface $listener
-	 * @return AbstractThreadPoolMediator
-	 */
-	public function removeListener(ListenerInterface $listener): self
-	{
-		$this->mediator->removeListener($listener);
-
-		return $this;
-	}
-
-	/**
-	 * @param string              $eventName
-	 * @param AbstractThread|null $thread
-	 */
-	protected function notify(string $eventName, ?AbstractThread $thread = null)
-	{
-		$this->getMediator()->notify(EventPoolFactory::create($eventName, $this, $thread));
-	}
+    /** @var Mediator */
+    private $mediator;
+
+    /**
+     * @return Mediator
+     */
+    protected function getMediator()
+    {
+        return $this->mediator;
+    }
+
+    /**
+     * ThreadPoolMediator constructor.
+     */
+    public function __construct()
+    {
+        $this->mediator = new Mediator();
+    }
+
+    /**
+     * @param ListenerInterface $listener
+     * @return AbstractThreadPoolMediator
+     */
+    public function addListener(ListenerInterface $listener): self
+    {
+        $this->mediator->addListener($listener);
+
+        return $this;
+    }
+
+    /**
+     * @param ListenerInterface $listener
+     * @return AbstractThreadPoolMediator
+     */
+    public function removeListener(ListenerInterface $listener): self
+    {
+        $this->mediator->removeListener($listener);
+
+        return $this;
+    }
+
+    /**
+     * @param string              $eventName
+     * @param AbstractThread|null $thread
+     */
+    protected function notify(string $eventName, ?AbstractThread $thread = null)
+    {
+        $this->getMediator()->notify(EventPoolFactory::create($eventName, $this, $thread));
+    }
 
 }

src/ThreadPool.php

Indentation +266 added lines, -266 removed lines

@@ -7,272 +7,272 @@
 
 class ThreadPool extends AbstractThreadPoolMediator
 {
-	// 0.2s
-	private const SLEEP_TIME_MS = 50000;
-
-	/** @var AbstractThread[] $childs */
-	private $threads;
-
-	/** @var AbstractThread[] $toRunThreads */
-	private $toRunThreads;
-
-	/** @var AbstractThread[] $runningChilds */
-	private $runningThreads;
-
-	/** @var bool $isRunning */
-	private $isRunning;
-
-	/** @var int $maxRunningThreadNb */
-	private $maxRunningThreadNb;
-
-	/**
-	 * ThreadPool constructor.
-	 */
-	public function __construct()
-	{
-		parent::__construct();
-		$this->threads = [];
-		$this->runningThreads = [];
-		$this->toRunThreads = [];
-		$this->isRunning = false;
-		$this->maxRunningThreadNb = 0;
-	}
-
-	/**
-	 *
-	 */
-	public function __destruct()
-	{
-		pcntl_waitpid(-1, $status, WNOHANG);
-	}
-
-	/**
-	 * @return AbstractThread[]
-	 */
-	public function getThreads(): array
-	{
-		return $this->threads;
-	}
-
-	/**
-	 * @param AbstractThread[] $threads
-	 * @return ThreadPool
-	 */
-	public function setThreads(array $threads): self
-	{
-		$this->threads = $threads;
-
-		return $this;
-	}
-
-	/**
-	 * @param AbstractThread $thread
-	 * @return ThreadPool
-	 */
-	public function addThread(AbstractThread $thread): self
-	{
-		$this->threads[] = $thread;
-
-		return $this;
-	}
-
-	/**
-	 * @return int
-	 */
-	public function getMaxRunningThreadNb(): int
-	{
-		return $this->maxRunningThreadNb;
-	}
-
-	/**
-	 * @param int $maxRunningThreadNb
-	 * @return ThreadPool
-	 */
-	public function setMaxRunningThreadNb(int $maxRunningThreadNb): self
-	{
-		$this->maxRunningThreadNb = $maxRunningThreadNb;
-
-		return $this;
-	}
-
-	/**
-	 * @return AbstractThread[]
-	 */
-	public function getToRunThreads(): array
-	{
-		return $this->toRunThreads;
-	}
-
-	/**
-	 * @return AbstractThread[]
-	 */
-	public function getRunningThreads(): array
-	{
-		return $this->runningThreads;
-	}
-
-	/**
-	 * @throws ThreadException
-	 */
-	public function run()
-	{
-		$this->checkEnv();
-		$this->initRun();
-
-		while ($this->isRunningThreads()) {
-			$this->waitOnThreads();
-		}
-
-		$this->resetRun();
-	}
-
-	/**
-	 * @return bool
-	 * @throws ThreadException
-	 */
-	private function isRunningThreads(): bool
-	{
-		if (count($this->toRunThreads) > 0) {
-			while (count($this->runningThreads) < $this->maxRunningThreadNb && count($this->toRunThreads) > 0) {
-				$this->createThreadProcess(array_shift($this->toRunThreads));
-			}
-		}
-
-		return count($this->runningThreads) > 0;
-	}
-
-	/**
-	 * can't test some part of it this since we can't unit-test in web and we're never in a child
-	 * process when pid 0 when unit-testing since the coverage is done by the parent thread
-	 *
-	 * @param AbstractThread $thread
-	 * @throws ThreadException
-	 */
-	private function createThreadProcess(AbstractThread $thread)
-	{
-		$pid = pcntl_fork();
-
-		switch ($pid) {
-			case -1: //error forking
-				// @codeCoverageIgnoreStart
-				throw new ThreadException('Error while trying to fork. Check your server installation');
-				// @codeCoverageIgnoreEnd
-			case 0: // child
-				// @codeCoverageIgnoreStart
+    // 0.2s
+    private const SLEEP_TIME_MS = 50000;
+
+    /** @var AbstractThread[] $childs */
+    private $threads;
+
+    /** @var AbstractThread[] $toRunThreads */
+    private $toRunThreads;
+
+    /** @var AbstractThread[] $runningChilds */
+    private $runningThreads;
+
+    /** @var bool $isRunning */
+    private $isRunning;
+
+    /** @var int $maxRunningThreadNb */
+    private $maxRunningThreadNb;
+
+    /**
+     * ThreadPool constructor.
+     */
+    public function __construct()
+    {
+        parent::__construct();
+        $this->threads = [];
+        $this->runningThreads = [];
+        $this->toRunThreads = [];
+        $this->isRunning = false;
+        $this->maxRunningThreadNb = 0;
+    }
+
+    /**
+     *
+     */
+    public function __destruct()
+    {
+        pcntl_waitpid(-1, $status, WNOHANG);
+    }
+
+    /**
+     * @return AbstractThread[]
+     */
+    public function getThreads(): array
+    {
+        return $this->threads;
+    }
+
+    /**
+     * @param AbstractThread[] $threads
+     * @return ThreadPool
+     */
+    public function setThreads(array $threads): self
+    {
+        $this->threads = $threads;
+
+        return $this;
+    }
+
+    /**
+     * @param AbstractThread $thread
+     * @return ThreadPool
+     */
+    public function addThread(AbstractThread $thread): self
+    {
+        $this->threads[] = $thread;
+
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    public function getMaxRunningThreadNb(): int
+    {
+        return $this->maxRunningThreadNb;
+    }
+
+    /**
+     * @param int $maxRunningThreadNb
+     * @return ThreadPool
+     */
+    public function setMaxRunningThreadNb(int $maxRunningThreadNb): self
+    {
+        $this->maxRunningThreadNb = $maxRunningThreadNb;
+
+        return $this;
+    }
+
+    /**
+     * @return AbstractThread[]
+     */
+    public function getToRunThreads(): array
+    {
+        return $this->toRunThreads;
+    }
+
+    /**
+     * @return AbstractThread[]
+     */
+    public function getRunningThreads(): array
+    {
+        return $this->runningThreads;
+    }
+
+    /**
+     * @throws ThreadException
+     */
+    public function run()
+    {
+        $this->checkEnv();
+        $this->initRun();
+
+        while ($this->isRunningThreads()) {
+            $this->waitOnThreads();
+        }
+
+        $this->resetRun();
+    }
+
+    /**
+     * @return bool
+     * @throws ThreadException
+     */
+    private function isRunningThreads(): bool
+    {
+        if (count($this->toRunThreads) > 0) {
+            while (count($this->runningThreads) < $this->maxRunningThreadNb && count($this->toRunThreads) > 0) {
+                $this->createThreadProcess(array_shift($this->toRunThreads));
+            }
+        }
+
+        return count($this->runningThreads) > 0;
+    }
+
+    /**
+     * can't test some part of it this since we can't unit-test in web and we're never in a child
+     * process when pid 0 when unit-testing since the coverage is done by the parent thread
+     *
+     * @param AbstractThread $thread
+     * @throws ThreadException
+     */
+    private function createThreadProcess(AbstractThread $thread)
+    {
+        $pid = pcntl_fork();
+
+        switch ($pid) {
+            case -1: //error forking
+                // @codeCoverageIgnoreStart
+                throw new ThreadException('Error while trying to fork. Check your server installation');
+                // @codeCoverageIgnoreEnd
+            case 0: // child
+                // @codeCoverageIgnoreStart
                 $thread->setMediator($this->getMediator());
-				$this->processThread($thread);
-				break;
-				// @codeCoverageIgnoreEnd
-			default: //parent
-				$thread->setPid($pid);
-				$this->runningThreads[] = $thread;
-				$this->notify(PoolEvent::POOL_NEW_THREAD, $thread);
-				$this->startRunStatus();
-		}
-	}
-
-	/**
-	 *
-	 */
-	private function waitOnThreads()
-	{
-		$this->notify(PoolEvent::POOL_PRE_WAIT_TICK);
-		foreach ($this->runningThreads as $k => $thread) {
-
-			$res = pcntl_waitpid($thread->getPid(), $status, WNOHANG);
-			$this->notify(PoolEvent::POOL_WAIT_TICK_PID);
-
-			if ($res === -1 || $res > 0) {
-				$this->notify(PoolEvent::POOL_WAIT_TICK_PID_REMOVED, $thread);
-				unset($this->runningThreads[$k]);
-			}
-
-		}
-		$this->notify(PoolEvent::POOL_POST_WAIT_TICK);
-
-		usleep(self::SLEEP_TIME_MS);
-	}
-
-	/**
-	 * @codeCoverageIgnore Can't test since this is only run in a child thread.. which doesnt' go throug the
-	 * unit-test coverage which is only done in the main process
-	 * @param AbstractThread $thread
-	 * @throws ThreadException
-	 */
-	private function processThread(AbstractThread $thread)
-	{
-		$this->notify(PoolEvent::THREAD_PRE_PROCESS, $thread);
-		$response = $thread->run();
-		$this->notify(PoolEvent::THREAD_POST_PROCESS, $thread);
-
-		switch ($response) {
-			case AbstractThread::EXIT_STATUS_SUCCESS:
-				$this->notify(PoolEvent::THREAD_EXIT_SUCCESS, $thread);
-				break;
-			case AbstractThread::EXIT_STATUS_ERROR:
-				$this->notify(PoolEvent::THREAD_EXIT_ERROR, $thread);
-				break;
-			default:
-				$this->notify(PoolEvent::THREAD_EXIT_UNKNOWN, $thread);
-		}
-
-		exit($response);
-	}
-
-	/**
-	 * Can't test the exception is not in cli since php-unit is only run in cli environment
-	 * @throws ThreadException
-	 */
-	private function checkEnv()
-	{
-		if (false === $this->isCli()) {
-			// @codeCoverageIgnoreStart
-			throw new ThreadException('Error. It is not safe to use process forking in other way than php-cli');
-			// @codeCoverageIgnoreEnd
-		}
-		if (0 === count($this->threads)) {
-			throw new ThreadException('Error. Can\'t run child threads processes without any added in the Pool');
-		}
-	}
-
-	/**
-	 *
-	 */
-	private function initRun()
-	{
-		$this->resetRun();
-	}
-
-	/**
-	 * @return bool
-	 */
-	private function isCli(): bool
-	{
-		return PHP_SAPI === 'cli';
-	}
-
-	/**
-	 *
-	 */
-	private function startRunStatus()
-	{
-		if (false === $this->isRunning) {
-			$this->notify(PoolEvent::POOL_RUN_START);
-			$this->isRunning = true;
-		}
-	}
-
-	/**
-	 *
-	 */
-	private function resetRun()
-	{
-		if (true === $this->isRunning) {
-			$this->notify(PoolEvent::POOL_RUN_STOP);
-		}
-		$this->isRunning = false;
-		$this->toRunThreads = $this->threads;
-		$this->runningThreads = [];
-	}
+                $this->processThread($thread);
+                break;
+                // @codeCoverageIgnoreEnd
+            default: //parent
+                $thread->setPid($pid);
+                $this->runningThreads[] = $thread;
+                $this->notify(PoolEvent::POOL_NEW_THREAD, $thread);
+                $this->startRunStatus();
+        }
+    }
+
+    /**
+     *
+     */
+    private function waitOnThreads()
+    {
+        $this->notify(PoolEvent::POOL_PRE_WAIT_TICK);
+        foreach ($this->runningThreads as $k => $thread) {
+
+            $res = pcntl_waitpid($thread->getPid(), $status, WNOHANG);
+            $this->notify(PoolEvent::POOL_WAIT_TICK_PID);
+
+            if ($res === -1 || $res > 0) {
+                $this->notify(PoolEvent::POOL_WAIT_TICK_PID_REMOVED, $thread);
+                unset($this->runningThreads[$k]);
+            }
+
+        }
+        $this->notify(PoolEvent::POOL_POST_WAIT_TICK);
+
+        usleep(self::SLEEP_TIME_MS);
+    }
+
+    /**
+     * @codeCoverageIgnore Can't test since this is only run in a child thread.. which doesnt' go throug the
+     * unit-test coverage which is only done in the main process
+     * @param AbstractThread $thread
+     * @throws ThreadException
+     */
+    private function processThread(AbstractThread $thread)
+    {
+        $this->notify(PoolEvent::THREAD_PRE_PROCESS, $thread);
+        $response = $thread->run();
+        $this->notify(PoolEvent::THREAD_POST_PROCESS, $thread);
+
+        switch ($response) {
+            case AbstractThread::EXIT_STATUS_SUCCESS:
+                $this->notify(PoolEvent::THREAD_EXIT_SUCCESS, $thread);
+                break;
+            case AbstractThread::EXIT_STATUS_ERROR:
+                $this->notify(PoolEvent::THREAD_EXIT_ERROR, $thread);
+                break;
+            default:
+                $this->notify(PoolEvent::THREAD_EXIT_UNKNOWN, $thread);
+        }
+
+        exit($response);
+    }
+
+    /**
+     * Can't test the exception is not in cli since php-unit is only run in cli environment
+     * @throws ThreadException
+     */
+    private function checkEnv()
+    {
+        if (false === $this->isCli()) {
+            // @codeCoverageIgnoreStart
+            throw new ThreadException('Error. It is not safe to use process forking in other way than php-cli');
+            // @codeCoverageIgnoreEnd
+        }
+        if (0 === count($this->threads)) {
+            throw new ThreadException('Error. Can\'t run child threads processes without any added in the Pool');
+        }
+    }
+
+    /**
+     *
+     */
+    private function initRun()
+    {
+        $this->resetRun();
+    }
+
+    /**
+     * @return bool
+     */
+    private function isCli(): bool
+    {
+        return PHP_SAPI === 'cli';
+    }
+
+    /**
+     *
+     */
+    private function startRunStatus()
+    {
+        if (false === $this->isRunning) {
+            $this->notify(PoolEvent::POOL_RUN_START);
+            $this->isRunning = true;
+        }
+    }
+
+    /**
+     *
+     */
+    private function resetRun()
+    {
+        if (true === $this->isRunning) {
+            $this->notify(PoolEvent::POOL_RUN_STOP);
+        }
+        $this->isRunning = false;
+        $this->toRunThreads = $this->threads;
+        $this->runningThreads = [];
+    }
 
 }