static function run()
{
$table = new swoole_table(1024 * 256);
$table->column('index', swoole_table::TYPE_INT);
$table->column('serid', swoole_table::TYPE_INT);
$table->column('data', swoole_table::TYPE_STRING, 64);
$table->create();
self::$table = $table;
for ($i = 0; $i < self::$key_num; $i++) {
$key = 'user_' . (self::$key_base + $i);
$ret = self::$table->set($key, array('index' => $i, 'serid' => rand(1000, 9999), 'data' => "hello_world_{$i}"));
if (!$ret) {
echo "count {$i} failed.";
break;
}
}
for ($i = 0; $i < self::$worker_num; $i++) {
$process = new swoole_process('UnitTest_Table::worker');
$process->start();
$workers[$i] = $process;
}
for ($i = 0; $i < self::$worker_num; $i++) {
$exit = swoole_process::wait();
echo "worker[{$i}] exit\n";
}
}
function forkChildInWorker()
{
global $serv;
echo "on worker start\n";
$process = new swoole_process(function (swoole_process $worker) {
// $serv = new swoole_server( "0.0.0.0", 9503 );
// $serv->set(array(
// 'worker_num' => 1
// ));
// $serv->on ( 'receive', function (swoole_server $serv, $fd, $from_id, $data) {
// $serv->send ( $fd, "Swoole: " . $data );
// $serv->close ( $fd );
// });
// $serv->start ();
// swoole_event_add ($worker->pipe, function ($pipe) use ($worker) {
// echo $worker->read()."\n";
// });
// swoole_timer_add (1000, function ($interval) use ($worker) {
// echo "#{$worker->pid} child process timer $interval\n"; // 如果worker中没有定时器，则会输出 process timer xxx
// });
});
$pid = $process->start();
echo "Fork child process success. pid={$pid}\n";
//保存子进程对象，这里如果不保存，那对象会被销毁，管道也会被关闭
$serv->childprocess = $process;
}
function run($options)
{
$asDaemon = isset($options['asDaemon']) ? $options['asDaemon'] : 0;
if ($asDaemon) {
\swoole_process::daemon();
}
$pids = [];
$workers = [];
for ($i = 0; $i < $this->worker_num; $i++) {
$process = new \swoole_process($this->workerStart, $this->redirect_stdout);
$process->id = $i;
$pid = $process->start();
$pids[] = $pid;
$workers[$pid] = $process;
}
$pidFile = isset($options['pidFile']) ? $options['pidFile'] : 0;
if ($pidFile) {
$ppid = posix_getpid();
$pids[] = $ppid;
file_put_contents($pidFile, implode("|", $pids));
}
\swoole_process::signal(SIGTERM, function () use($workers) {
exit(0);
});
\swoole_process::signal(SIGINT, function () {
exit(0);
});
\swoole_process::wait(false);
return $workers;
}
/**
* @brief 启动子进程
* @param \swoole_process $worker
*/
public function start(\swoole_process $worker)
{
$this->_worker = $worker;
swoole_event_add($worker->pipe, function ($pipe) use($worker) {
echo $worker->read() . PHP_EOL;
});
$this->worker();
}
/**
* swoole_process回调函数
* @param swoole_process $worker
*/
function callback_vmstat(swoole_process $worker)
{
global $table;
$vmstat = $table->get('vmstat');
$cmd = $vmstat['cmd'];
$interval = $vmstat['interval'];
$count = $vmstat['count'];
$worker->exec($cmd, array($interval, $count));
}
/**
* 创建一个子进程
* @param $task
*/
public function create_process($id, $task)
{
$this->task = $task;
$process = new swoole_process(array($this, "run"));
if (!($pid = $process->start())) {
}
//记录当前任务
Crontab::$task_list[$pid] = array("start" => microtime(true), "id" => $id, "task" => $task);
}
function callback_function(swoole_process $worker)
{
//echo "Worker: start. PID=".$worker->pid."\n";
//recv data from master
$recv = $worker->pop();
echo "From Master: {$recv}\n";
sleep(2);
$worker->exit(0);
}
function callback_function(swoole_process $worker)
{
echo "Worker: start. PID=" . $worker->pid . "\n";
//recv data from master
$recv = $worker->read();
echo "From Master: {$recv}\n";
//send data to master
$worker->write("hello master\n");
sleep(2);
$worker->exit(0);
}
function callback_process_function(swoole_process $worker)
{
set_time_limit(300);
$task = json_decode($worker->read(), true);
$worker->name('crontab.php worker=' . $task['uniqid']);
$Handle = new TimingCall_Handle($task);
$Handle->upNextExecuteTime();
$Handle->refreshStatistics();
$Handle->Execute();
$worker->exit(0);
}
/**
* 创建一个子进程
* @param $classname
* @param $number
* @param $redis
*/
public function create_process($classname, $number, $redis)
{
$this->workers["classname"] = $classname;
$this->workers["number"] = $number;
$this->workers["redis"] = $redis;
$process = new swoole_process(array($this, "run"));
if (!($pid = $process->start())) {
}
//记录当前任务
Crontab::$task_list[$pid] = array("start" => microtime(true), "classname" => $classname, "number" => $number, "redis" => $redis, "type" => "worker", "process" => $process);
}
private function worker_run()
{
for ($i = 0; $i < $this->process_number; $i++) {
$process = new swoole_process(array($this, "worker_callback"), false, true);
$pid = $process->start();
self::$workers[$i] = $process;
self::$workers_pipe[$process->pipe] = $process;
self::$restart_event[$i] = event_new();
//var_dump($process->pipe);
event_set(self::$restart_event[$i], $process->pipe, EV_READ | EV_PERSIST, array($this, "relisten"));
event_base_set(self::$restart_event[$i], $this->event_base);
event_add(self::$restart_event[$i]);
}
}
function callback_function(swoole_process $worker)
{
//echo "Worker: start. PID=".$worker->pid."\n";
//recv data from master
$cnt = 0;
while ($cnt < 2) {
// 如果队列里没有数据，则pop方法阻塞等待
$recv = $worker->pop();
echo "From Master: {$recv}\n";
$cnt++;
}
sleep(1);
$worker->exit(0);
}
/**
* @brief 读取管道中的消息包体
* @param \swoole_process $process
*/
public function readPipe(\swoole_process $process)
{
while (false !== ($content = $process->read())) {
if (false === $content) {
\Aha\Log\Sys::log()->error(array('IPC_PIPE_READ_ERR' => $content));
break;
} else {
$this->append($content);
}
if (strlen($content) < 8191) {
break;
}
}
}
function child_async(swoole_process $worker)
{
//echo "Worker: start. PID=".$worker->pid."\n";
//recv data from master
$GLOBALS['worker'] = $worker;
global $argv;
$worker->name("{$argv[0]}: worker");
swoole_process::signal(SIGTERM, function ($signal_num) use($worker) {
echo "signal call = {$signal_num}, #{$worker->pid}\n";
});
swoole_event_add($worker->pipe, function ($pipe) use($worker) {
$recv = $worker->read();
echo "From Master: {$recv}\n";
$worker->write("hello master\n");
});
}
function master_process($workers)
{
//监听子进程，如果停止，会再拉起来
swoole_process::signal(SIGCHLD, function ($signo) use(&$workers) {
while (1) {
$ret = swoole_process::wait(false);
if ($ret) {
$pid = $ret['pid'];
//这里实现一个自动拉起的能力
$child_process = $workers[$pid];
logprint('info', "Worker Exit, kill_signal={$ret['signal']} PID=" . $pid);
$new_pid = $child_process->start();
$workers[$new_pid] = $child_process;
unset($workers[$pid]);
} else {
break;
}
}
});
//kill -10 结束全部程序
swoole_process::signal(SIGUSR1, function ($signo) use(&$workers) {
swoole_process::signal(SIGCHLD, null);
foreach ($workers as $pid => $worker) {
swoole_process::kill($pid);
}
//处理子进程，然后自己退出
exit;
});
}
public static function register_signal()
{
swoole_process::signal(SIGUSR2, function ($signal_num) {
echo "收到结束信号，结束进程\n";
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 static function createWorkerProcess($className, $number, $options)
{
$reflector = new \ReflectionClass($className);
if (!$reflector->implementsInterface("PHPKit\\Console\\Workers\\IWorker")) {
defined('PHPKIT_RUN_DEBUG') && syslog(LOG_ERR, 'class [' . $className . '] is error');
self::stop();
} else {
$process = new \swoole_process(function ($worker) use($className, $number, $options) {
$worker->name(self::$child_process_name . str_replace('\\', '_', $className) . '_' . $number);
$handler = new $className($options);
$handler->tick($worker);
});
$pid = $process->start();
self::$worker_list[$pid] = ['className' => $className, 'number' => $number, 'process' => $process, 'options' => $options];
defined('PHPKIT_RUN_DEBUG') && syslog(LOG_INFO, 'create child process success:' . $pid);
}
}
/**
* @brief 启动子进程
*/
public function start()
{
$workerNum = $this->_objAha->getConfig()->get('aha', 'worker_num');
for ($i = 0; $i < $workerNum; $i++) {
$worker = new \Daemon\Asyncworker($this->_objAha);
$process = new \swoole_process(array($worker, 'start'));
//$process->daemon();
$workerPid = $process->start();
$this->_workers[$workerPid] = $process;
$process->write("worker started!");
}
foreach ($this->_workers as $process) {
$workerPid = \swoole_process::wait();
echo "[Worker Shutdown][WorkerId] {$workerPid} " . PHP_EOL;
unset($this->_workers[$workerPid]);
}
}
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();
}
});
}
public function __construct(\swoole_server &$server, $redirect_stdin_stdout = false, $create_pipe = true)
{
if ($server) {
$this->_server = $server;
parent::__construct([$this, 'OnWorkerStart'], $redirect_stdin_stdout, $create_pipe);
} else {
die("BaseProcess->__construct error: \$server is null.\n");
}
}
/**
* 创建一个子进程
* @param $task
*/
public function create_process($id, $task)
{
$this->task = $task;
$process = new swoole_process(array($this, "run"));
if (!($pid = $process->start())) {
}
//记录当前任务
Crontab::$task_list[$pid] = array("start" => microtime(true), "id" => $id, "task" => $task, "type" => "crontab", "process" => $process);
swoole_event_add($process->pipe, function ($pipe) use($process) {
$task = $process->read();
list($pid, $sec) = explode(",", $task);
if (isset(Crontab::$task_list[$pid])) {
$tasklist = Crontab::$task_list[$pid];
Crontab::$delay[time() + $sec] = $tasklist["task"];
$process->write($task);
}
});
}
/**
* 停止服务
*/
public static function stop()
{
$pid = file_get_contents(self::$pid_file);
if ($pid) {
if (\swoole_process::kill($pid, 0)) {
\swoole_process::kill($pid, SIGTERM);
} else {
@unlink(self::$pid_file);
}
defined('PHPKIT_RUN_DEBUG') && syslog(LOG_INFO, self::$process_name . ' exit success');
}
}
function onReceive($pipe)
{
global $workers;
$worker = $workers[$pipe];
$data = $worker->read();
if ($data == false) {
//表示子进程已关闭，回收它
$status = swoole_process::wait();
echo "Worker#{$status['pid']} exit\n";
} else {
echo "RECV: " . $data;
}
}
public function checkStatus()
{
$args = getopt('s:');
if (isset($args['s'])) {
switch ($args['s']) {
case 'reload':
$pid = file_get_contents($this->cacheDir . "/pid");
echo "当前进程" . $pid . "\n";
echo "热重启中\n";
if ($pid) {
if (swoole_process::kill($pid, 0)) {
swoole_process::kill($pid, SIGUSR1);
}
}
echo "重启完成\n";
swoole_process::daemon();
break;
default:
break;
}
exit;
}
}
<?php
const WORK_NUM = 250;
for ($i = 0; $i < WORK_NUM; $i++) {
$process = new swoole_process(function ($worker) {
$worker->exec("/usr/bin/php", array("/mnt/hgfs/work/swoole/swoole_task/chat_room/client.php"));
});
$process->start();
}
for ($i = 0; $i < WORK_NUM; $i++) {
swoole_process::wait();
// 回收结束运行的子进程
}
/**
*是否以守护进程的方式运行
*/
private static function daemon()
{
if (self::$daemon === true) {
swoole_process::daemon();
}
}
function my_onWorkerStart($serv, $worker_id)
{
processRename($serv, $worker_id);
if (!$serv->taskworker) {
swoole_process::signal(SIGUSR2, function ($signo) {
echo "SIGNAL: {$signo}\n";
});
}
//forkChildInWorker();
// setTimerInWorker($serv, $worker_id);
}
<?php
function timeout($tm)
{
echo time() . " Timeout #{$tm}\n";
if ($tm == 3) {
global $timer4;
swoole_timer_clear($timer4);
}
}
$timer1 = swoole_timer_after(1000, function ($id) {
echo "hello world";
global $timer1;
swoole_timer_clear($timer1);
}, 1);
$timer2 = swoole_timer_after(2000, 'timeout', 2);
$timer3 = swoole_timer_after(4000, 'timeout', 3);
$timer4 = swoole_timer_after(8000, 'timeout', 4);
$timer5 = swoole_timer_after(10000, 'timeout', 5);
swoole_process::signal(SIGTERM, function () {
swoole_event_exit();
});
var_dump($timer1, $timer2, $timer3, $timer4, $timer5);
<?php
$table = new swoole_table(1024);
$table->column('id', swoole_table::TYPE_INT, 4);
//1,2,4,8
$table->column('name', swoole_table::TYPE_STRING, 64);
$table->column('num', swoole_table::TYPE_FLOAT);
$table->create();
$worker = new swoole_process('child1', false, false);
$worker->start();
//child
function child1($worker)
{
global $table;
$table->set('*****@*****.**', array('id' => 145, 'name' => 'rango', 'num' => 3.1415));
$table->set('*****@*****.**', array('id' => 358, 'name' => "Rango1234", 'num' => 3.1415));
$table->set('*****@*****.**', array('id' => 189, 'name' => 'rango3', 'num' => 3.1415));
sleep(100000);
}
//master
sleep(1);
$s = microtime(true);
for ($i = 0; $i < 1000; $i++) {
$arr = $table->get('*****@*****.**');
}
echo "use: " . (microtime(true) - $s) * 1000 . "ms\n";
//var_dump($table->get('*****@*****.**'));
sleep(100000);