function enableForConsumer($consumerId, $interval, $probeKey)
 {
     $_this = $this;
     $this->enabled = true;
     if (!$this->instant) {
         // register consumer
         $newConsumerId = !isset($this->consumerTimers[$consumerId]);
         if ($interval > 0 && $newConsumerId) {
             $this->consumerTimers[$consumerId] = setInterval(function () use($_this, $consumerId) {
                 $_this->sample($consumerId);
             }, $interval);
         }
         // enable with delayed disabling
         if (!empty($this->disableDelay)) {
             clearTimeout($this->disableDelay);
         }
         $this->disableDelay = setTimeout(function () use($_this) {
             //echo "\ndisabled " . $_this->name;
             $_this->enabled = false;
             foreach ($_this->consumerTimers as $consumerId => $timer) {
                 clearInterval($timer);
             }
             $_this->consumerTimers = array();
         }, PROBE_DISABLE_DELAY);
     }
 }

 /**
  * Called when the worker is ready to go.
  * @return void
  */
 public function onReady()
 {
     $appInstance = $this;
     // a reference to this application instance for ExampleWebSocketRoute
     \PHPDaemon\Servers\WebSocket\Pool::getInstance()->addRoute('ExamplePubSub', function ($client) use($appInstance) {
         return new ExamplePubSubWebSocketRoute($client, $appInstance);
     });
     $this->sql = \PHPDaemon\Clients\MySQL\Pool::getInstance();
     $this->pubsub = new \PHPDaemon\PubSub\PubSub();
     $this->pubsub->addEvent('usersNum', \PHPDaemon\PubSub\PubSubEvent::init()->onActivation(function ($pubsub) use($appInstance) {
         \PHPDaemon\Core\Daemon::log('onActivation');
         if (isset($pubsub->event)) {
             \PHPDaemon\Core\Timer::setTimeout($pubsub->event, 0);
             return;
         }
         $pubsub->event = setTimeout(function ($timer) use($pubsub, $appInstance) {
             $appInstance->sql->getConnection(function ($sql) use($pubsub) {
                 if (!$sql->connected) {
                     return;
                 }
                 $sql->query('SELECT COUNT(*) `num` FROM `dle_users`', function ($sql, $success) use($pubsub) {
                     $pubsub->pub(sizeof($sql->resultRows) ? $sql->resultRows[0]['num'] : 'null');
                 });
             });
             $timer->timeout(5000000.0);
             // 5 seconds
         }, 0);
     })->onDeactivation(function ($pubsub) {
         if (isset($pubsub->event)) {
             \PHPDaemon\Core\Timer::cancelTimeout($pubsub->event);
         }
     }));
 }

 /**
  * Called when the worker is ready to go
  * @return void
  */
 public function onReady()
 {
     $this->redis = \PHPDaemon\Clients\Redis\Pool::getInstance();
     $this->redis->multi(function ($multi) {
         // "OK"
         D('start multi: ' . $multi->result);
         $multi->set('test1', 'value1', function ($redis) use($multi) {
             // "QUEUED"
             D('in multi 1: ' . $redis->result);
             $this->redis->set('test1', 'value1-new', function ($redis) {
                 // "OK", not "QUEUED"
                 D('out multi 1: ' . $redis->result);
             });
             setTimeout(function ($timer) use($multi) {
                 // "QUEUED"
                 $multi->set('test2', 'value2', function ($redis) use($multi) {
                     D('in multi 2: ' . $redis->result);
                     $multi->exec(function ($redis) {
                         D('exec');
                         D($redis->result);
                     });
                 });
                 $timer->free();
             }, 200000.0);
         });
     });
 }

 /**
  * Called when the connection is handshaked (at low-level), and peer is ready to recv. data
  * @return void
  */
 public function onReady()
 {
     $conn = $this;
     $this->keepaliveTimer = setTimeout(function ($timer) use($conn) {
         $conn->ping();
     }, 10000000.0);
 }

 public function onReady()
 {
     $appInstance = $this;
     setTimeout(function ($event) use($appInstance) {
         $appInstance->broadcastCall('hello', [\PHPDaemon\Core\Daemon::$process->getPid()]);
         $event->finish();
     }, 2000000.0);
 }

 /**
  * Called when the worker is ready to go.
  * @return void
  */
 public function onReady()
 {
     if ($this->config->enable->value) {
         $this->timer = setTimeout(function ($timer) {
             $this->touchCursor();
         }, 300000.0);
     }
 }

 /**
  * Called when the connection is handshaked (at low-level), and peer is ready to recv. data
  * @return void
  */
 public function onReady()
 {
     $this->createXMLStream();
     $this->startXMLStream();
     $this->keepaliveTimer = setTimeout(function ($timer) {
         $this->ping();
     }, 1000000.0 * 30);
 }

 /**
  * Called when the worker is ready to go.
  * @return void
  */
 public function onReady()
 {
     if ($this->isEnabled()) {
         $this->updateTimer = setTimeout(function ($timer) {
             $this->updateAllServers();
             $timer->timeout(2000000.0);
         }, 1);
     }
 }

 /**
  * Constructor
  * @return void
  */
 public function init()
 {
     $this->sessId = $this->attrs->sessId;
     $this->serverId = $this->attrs->serverId;
     $this->path = $this->attrs->path;
     // @TODO: revert timeout after request
     $this->upstream->setTimeouts($this->appInstance->config->networktimeoutread->value, $this->appInstance->config->networktimeoutwrite->value);
     $this->opts = $this->appInstance->getRouteOptions($this->attrs->path);
     $this->CORS();
     if ($this->isFinished()) {
         return;
     }
     if ($this->opts['cookie_needed'] && !$this instanceof Info) {
         if (isset($_COOKIE['JSESSIONID'])) {
             $val = $_COOKIE['JSESSIONID'];
             if (!is_string($val) || $val === '') {
                 $val = 'dummy';
             }
         } else {
             $val = 'dummy';
         }
         $this->setcookie('JSESSIONID', $val, 0, '/');
     }
     $this->contentType($this->contentType);
     if (!$this->cacheable) {
         $this->noncache();
         $this->header('X-Accel-Buffering: no');
     }
     if ($this->callbackParamEnabled) {
         if (!isset($_GET['c']) || !is_string($_GET['c']) || preg_match('~[^_\\.a-zA-Z0-9]~', $_GET['c'])) {
             $this->header('500 Internal Server Error');
             $this->out('"callback" parameter required');
             $this->finish();
             return;
         }
     }
     if (($f = $this->appInstance->config->heartbeatinterval->value) > 0) {
         $this->heartbeatTimer = setTimeout(function ($timer) {
             if (in_array('one-by-one', $this->pollMode)) {
                 $this->heartbeatOnFinish = true;
                 $this->stop();
                 return;
             }
             $this->sendFrame('h');
             if ($this->gcEnabled) {
                 $this->gcCheck();
             }
         }, $f * 1000000.0);
     }
     $this->afterHeaders();
     if ($this->poll) {
         $this->acquire(function () {
             $this->poll();
         });
     }
 }

 /**
  * Manager constructor.
  * @param $path
  */
 public function __construct($path, $threadsNum)
 {
     $this->threadsNum = $threadsNum;
     $this->path = $path;
     $this->queue = new StackCallbacks();
     $this->reloadCheckTimer = setTimeout(function ($ev) {
         FileSystem::stat($this->path, function ($path, $stat) {
             if (!$stat) {
                 $this->stop();
                 $this->free();
             }
             if ($this->reloadCheckLastModified >= $stat['mtime']) {
                 return;
             }
             $this->reloadCheckLastModified = $stat['mtime'];
             $this->stop();
             $this->start();
         });
         $ev->timeout(static::RELOAD_CHECK_INTERVAL);
     }, 1);
 }

 /**
  * __construct
  * @param Application $appInstance [@todo description]
  * @param string $id [@todo description]
  * @param array $server [@todo description]
  * @return void
  */
 public function __construct($appInstance, $id, $server)
 {
     $this->onWrite = new StackCallbacks();
     $this->id = $id;
     $this->appInstance = $appInstance;
     $this->server = $server;
     if (isset($this->server['HTTP_COOKIE'])) {
         Generic::parseStr(strtr($this->server['HTTP_COOKIE'], Generic::$hvaltr), $this->cookie);
     }
     if (isset($this->server['QUERY_STRING'])) {
         Generic::parseStr($this->server['QUERY_STRING'], $this->get);
     }
     $this->addr = $server['REMOTE_ADDR'];
     $this->finishTimer = setTimeout(function ($timer) {
         $this->finish();
     }, $this->timeout * 1000000.0);
     $this->appInstance->subscribe('c2s:' . $this->id, [$this, 'c2s']);
     $this->appInstance->subscribe('poll:' . $this->id, [$this, 'poll'], function ($redis) {
         $this->appInstance->publish('state:' . $this->id, 'started', function ($redis) {
             // @TODO: remove this callback
         });
     });
 }

 /**
  * End request
  * @return void
  */
 public function endRequest($req, $appStatus, $protoStatus)
 {
     if ($protoStatus === -1) {
         $this->close();
     } else {
         if ($req->attrs->chunked) {
             $this->write("0\r\n\r\n");
         }
         if (isset($req->keepalive) && $req->keepalive && $this->pool->config->keepalive->value) {
             $this->keepaliveTimer = setTimeout(function ($timer) {
                 $this->finish();
             }, $this->pool->config->keepalive->value);
         } else {
             $this->finish();
         }
     }
     $this->freeRequest($req);
 }

            setTimeout($Redis, $arr['key'], $arr['expire']);
            break;
        case $Redis::REDIS_LIST:
            echo "list\n";
            foreach ($arr['val'] as $v) {
                $Redis->rPush($arr['key'], $v);
            }
            setTimeout($Redis, $arr['key'], $arr['expire']);
            break;
        case $Redis::REDIS_SET:
            echo "set\n";
            foreach ($arr['val'] as $v) {
                $Redis->sAdd($arr['key'], $v);
            }
            setTimeout($Redis, $arr['key'], $arr['expire']);
            break;
        case $Redis::REDIS_ZSET:
            echo "zset\n";
            foreach ($arr['val'] as $v => $score) {
                $Redis->zAdd($arr['key'], $score, $v);
            }
            setTimeout($Redis, $arr['key'], $arr['expire']);
            break;
        default:
            //echo "unknown\n";
            continue;
            break;
    }
}
$Redis->close();
fclose($file);

 public function onReady()
 {
     if ($this->isEnabled()) {
         \PHPDaemon\Servers\WebSocket\Pool::getInstance()->addRoute('Chat', array($this, 'onHandshake'));
         $app = $this;
         $this->timer = setTimeout(function ($timer) use($app) {
             foreach ($app->tags as $tag) {
                 $tag->touch();
             }
             $timer->timeout();
         }, 300000.0);
     }
 }

 function testTick()
 {
     $check = 0;
     setTimeout(function () use(&$check) {
         $check++;
     }, 1);
     nextTick(function () use(&$check) {
         $check++;
     });
     tick();
     $this->assertEquals(1, $check);
 }

 /**
  * @TODO DESCR
  * @return void
  */
 public function onHandshake()
 {
     $this->realRoute->client->sendFrameReal('o');
     if (($f = $this->sockjs->config->heartbeatinterval->value) > 0) {
         $this->heartbeatTimer = setTimeout(function ($timer) {
             $this->realRoute->client->sendFrameReal('h');
             $timer->timeout();
         }, $f * 1000000.0);
         $this->realRoute->onHandshake();
     }
 }

 /**
  * Called when we got UDP packet
  * @param resource $stream Descriptor
  * @param integer $events  Events
  * @param mixed $arg       Attached variable
  * @return boolean Success.
  */
 public function onReadUdp($stream = null, $events = 0, $arg = null)
 {
     if (Daemon::$config->logevents->value) {
         Daemon::$process->log(get_class($this) . '::' . __METHOD__ . ' invoked.');
     }
     if (Daemon::$process->reload) {
         return false;
     }
     if ($this->pool->maxConcurrency) {
         if ($this->pool->count() >= $this->pool->maxConcurrency) {
             $this->overload = true;
             return false;
         }
     }
     $host = null;
     do {
         $l = @socket_recvfrom($this->fd, $buf, 10240, MSG_DONTWAIT, $host, $port);
         if (!$l) {
             break;
         }
         $key = '[' . $host . ']:' . $port;
         if (!isset($this->portsMap[$key])) {
             if ($this->pool->allowedClients !== null) {
                 if (!self::netMatch($conn->pool->allowedClients, $host)) {
                     Daemon::log('Connection is not allowed (' . $host . ')');
                 }
                 continue;
             }
             $class = $this->pool->connectionClass;
             $conn = new $class(null, $this->pool);
             $conn->setDgram(true);
             $conn->onWriteEv(null);
             $conn->setPeername($host, $port);
             $conn->setParentSocket($this);
             $this->portsMap[$key] = $conn;
             $conn->timeoutRef = setTimeout(function ($timer) use($conn) {
                 $conn->finish();
                 $timer->finish();
             }, $conn->timeout * 1000000.0);
             $conn->onUdpPacket($buf);
         } else {
             $conn = $this->portsMap[$key];
             $conn->onUdpPacket($buf);
             Timer::setTimeout($conn->timeoutRef);
         }
     } while (true);
     return $host !== null;
 }

<?php

$http = new Event\HTTP();
$srv = $http->createServer(function ($req, $res) {
    $res->write("Hello World immediately\n");
    setTimeout(function () use(&$res) {
        $res->end("Goodbye world 5 seconds later\n");
    }, 5000);
});
$srv->listen(8080, '127.0.0.1');