public function run($worker)
 {
     swoole_timer_tick(1000, function ($timer_id) {
         static $index = 0;
         $index = $index + 1;
         $this->process->push("Hello");
         var_dump($index);
         if ($index == 10) {
             swoole_timer_clear($timer_id);
         }
     });
 }

 static function newAfterTimer()
 {
     $id = swoole_timer_tick(rand(1000, 10000), 'timer');
     G::$afterTimers[$id] = true;
     self::$index++;
     self::log(__METHOD__ . ": #{$id}");
 }

 private function online($who)
 {
     if (!isset($this->gens[$who])) {
         $this->gens[$who] = $this->messageGenerator($who);
         $this->sendUsers();
         $this->broadcast($who, $who . " is online.");
     }
     if ($this->timer == null) {
         $this->timer = swoole_timer_tick(3000, function () {
             try {
                 $users = $this->getAllUsers();
                 foreach ($users as $user) {
                     if (!isset($this->getMessage[$user]) && !isset($this->getUpdateUsers[$user])) {
                         if (!isset($this->maybeOffline[$user])) {
                             $this->maybeOffline[$user] = true;
                         } else {
                             $this->offline($user);
                         }
                     } else {
                         if (isset($this->maybeOffline[$user])) {
                             unset($this->maybeOffline[$user]);
                         }
                     }
                 }
             } catch (\Exception $e) {
             }
         });
     }
 }

 public function onWorkerStart($serv, $worker_id)
 {
     if ($worker_id == 0) {
         $this->test = new Test();
         $this->test->index = 1;
         swoole_timer_tick(1000, array($this, 'onTick'), "Hello");
     }
 }

 /**
  *  注册定时任务
  */
 protected static function register_timer()
 {
     swoole_timer_tick(60000, function ($interval) {
         Test::load_config();
     });
     swoole_timer_tick(1000, function ($interval) {
         Test::do_something($interval);
     });
 }

 public static function registerTimer()
 {
     \swoole_timer_tick(60000, function ($id) {
         self::loadConfig();
         defined('PHPKIT_RUN_DEBUG') && syslog(LOG_INFO, 'reload config success');
     });
     \swoole_timer_tick(1000, function ($id) {
         self::loadTask($id);
     });
 }

 /**
  * [init 启动定时器]
  * @return [type] [description]
  */
 public static function init()
 {
     if (!isset(self::$tickKey)) {
         self::$tickKey = swoole_timer_tick(1000 * self::LOOPTIME, function () {
             //循环数组，踢出超时情况
             self::loop();
         });
         \SysLog::info(__METHOD__ . " init timer tick key == " . self::$tickKey, __CLASS__);
     }
 }

function callback_function(swoole_process $worker)
{
    global $config;
    swoole_timer_tick($config['time'], function () {
        $fp = stream_socket_client("tcp://127.0.0.1:9502", $code, $msg, 1);
        $http_request = "GET / HTTP/1.1\r\n\r\n";
        fwrite($fp, $http_request);
        fclose($fp);
    });
}

 public function addTimer()
 {
     swoole_timer_tick(10000, function ($timer_id, $params = null) {
         if ($this->is_tasking) {
             return;
         }
         $this->server->task();
         $this->is_tasking = true;
     });
 }

function my_process1($process)
{
    global $argv;
    var_dump($process);
    swoole_set_process_name("php {$argv[0]}: my_process1");
    swoole_timer_tick(2000, function ($id) {
        global $serv;
        $serv->sendMessage("hello", 1);
    });
}

 /**
  * [init 启动定时器]
  * @return [type] [description]
  */
 public static function init()
 {
     if (!self::$isOnTimer) {
         swoole_timer_tick(1000 * self::LOOPTIME, function ($timer_id) {
             //循环数组，踢出超时情况
             self::loop($timer_id);
             self::$isOnTimer = false;
         });
         self::$isOnTimer = true;
     }
 }

 public static function init()
 {
     if (self::$timer === null) {
         for ($i = 0; $i < self::SLOT_SIZE; $i++) {
             self::$eventSlots[$i] = array();
         }
         self::$timer = swoole_timer_tick(1000 * self::LOOP_TIME, function ($tid) {
             self::loop($tid);
         });
     }
 }

 /**
  * @brief 子进程做事情
  */
 public function worker()
 {
     $scheduler = $this->_objAha->getScheduler();
     swoole_timer_tick(5000, function () use($scheduler) {
         for ($i = 0; $i < 50; $i++) {
             $coroutine = $this->dbTest();
             if ($coroutine instanceof \Generator) {
                 $scheduler->newTask($coroutine);
                 $scheduler->run();
             }
         }
     });
 }

 protected function _initTimer()
 {
     $redoConf = $this->_objAha->getConfig()->get('aha', 'redo');
     $interval = $redoConf['interval'];
     $triggerInterval = $redoConf['trigger_interval'];
     //当前周期内 把上个周期内失败的进行重试
     swoole_timer_tick($interval, function () {
         $this->_redo();
     });
     //每个时钟周期检查是否有redo没有发完的消息包
     swoole_timer_tick($triggerInterval, function () {
         $this->_trigger();
     });
 }

 public function tick($worker)
 {
     $this->worker = $worker;
     swoole_timer_tick(500, function () {
         while (true) {
             $this->checkExit();
             $task = $this->getQueue();
             if (empty($task)) {
                 break;
             }
             $this->Run($task);
         }
     });
 }

 public function __construct()
 {
     $fp = stream_socket_client("tcp://127.0.0.1:9504", $code, $msg, 3);
     $http_request = "GET /index.html HTTP/1.1\r\n\r\n";
     fwrite($fp, $http_request);
     swoole_event_add($fp, function ($fp) {
         echo fread($fp, 8192);
         swoole_event_del($fp);
         fclose($fp);
     });
     swoole_timer_after(2000, function () {
         echo "2000ms timeout\n";
     });
     swoole_timer_tick(1000, function () {
         echo "1000ms interval\n";
     });
 }

 public function run()
 {
     $this->current_num = $this->min_worker_num;
     for ($i = 0; $i < $this->current_num; $i++) {
         $process = new swoole_process(array($this, 'task_run'), false, 2);
         $pid = $process->start();
         $this->process_list[$pid] = $process;
         $this->process_use[$pid] = 0;
     }
     foreach ($this->process_list as $process) {
         swoole_event_add($process->pipe, function ($pipe) use($process) {
             $data = $process->read();
             var_dump($data);
             $this->process_use[$data] = 0;
         });
     }
     swoole_timer_tick(1000, function ($timer_id) {
         static $index = 0;
         $index = $index + 1;
         $flag = true;
         foreach ($this->process_use as $pid => $used) {
             if ($used == 0) {
                 $flag = false;
                 $this->process_use[$pid] = 1;
                 $this->process_list[$pid]->write($index . "Hello");
                 break;
             }
         }
         if ($flag && $this->current_num < $this->max_worker_num) {
             $process = new swoole_process(array($this, 'task_run'), false, 2);
             $pid = $process->start();
             $this->process_list[$pid] = $process;
             $this->process_use[$pid] = 1;
             $this->process_list[$pid]->write($index . "Hello");
             $this->current_num++;
         }
         var_dump($index);
         if ($index == 10) {
             foreach ($this->process_list as $process) {
                 $process->write("exit");
             }
             swoole_timer_clear($timer_id);
             $this->process->exit();
         }
     });
 }

 protected function memoryCheck()
 {
     $process = new \swoole_process(function (\swoole_process $worker) {
         $worker->name("kerisy-rpcserver:memoryCheck");
         swoole_timer_tick(1000, function () {
             $serverName = "kerisy-rpcserver:master";
             Reload::load($serverName, 0.8);
             //                echo date('H:i:s')."\r\n";
             if (date('H:i') == '04:00') {
                 Reload::reload($serverName);
                 //休息70s
                 sleep(70);
             }
         });
     });
     $process->start();
 }

 public function work()
 {
     //是否有队列任务，有的话给worker进程发消息
     foreach ($this->workers as $pid => $worker) {
         \Log::info("队列worker{$pid}启动", [], 'tube.work');
         $data = $worker['tube'];
         if ($data) {
             $worker['process']->write($data);
         }
     }
     swoole_timer_tick(5000, function ($timerId) {
         if (!$this->pheanstalk->getConnection()->isServiceListening()) {
             //现在是一旦队列服务器崩溃的话，处理队列的主进程将退出。当然可以设置成等待，知道队列服务器恢复，只要将下列代码注释
             \Log::emergency("队列服务器崩溃了!TubeTick监听器退出", [], 'tube.tick');
             swoole_timer_clear($timerId);
             return;
         }
     });
 }

 /**
  * 定时任务计时器入口文件
  * @param int    $interval  定时器时间间隔，单位秒
  * @param string $hostinfo  监听主机
  */
 public function actionRun($interval = 3, $hostinfo = '0.0.0.0:9550')
 {
     $interval = $interval * 1000;
     //单位是秒转换为基本单位毫秒
     $this->parseHostPort($hostinfo);
     echo 'timer set ', $interval, ' ms ', PHP_EOL;
     //主定时器,按interval间隔执行，单位毫秒
     swoole_timer_tick($interval, function () {
         $this->execTasks();
     });
     //如果存在额外注册定时器
     if ($this->reg_timer) {
         foreach ($this->reg_timer as $reg) {
             $tick = $reg['interval'] * 1000;
             if (method_exists($this, $reg['func'])) {
                 swoole_timer_tick($interval, [$this, $reg['func']]);
             }
         }
     }
 }