创建守护进程步骤
首先我们要了解一些基本概念：
进程组 ：
每个进程也属于一个进程组
每个进程主都有一个进程组号，该号等于该进程组组长的PID号 .
一个进程只能为它自己或子进程设置进程组ID号
会话期：
会话期(session)是一个或多个进程组的集合。
setsid()函数可以建立一个对话期：
 如果，调用setsid的进程不是一个进程组的组长，此函数创建一个新的会话期。
(1)此进程变成该对话期的首进程
(2)此进程变成一个新进程组的组长进程。
(3)此进程没有控制终端，如果在调用setsid前，该进程有控制终端，那么与该终端的联系被解除。 如果该进程是一个进程组的组长，此函数返回错误。
(4)为了保证这一点，我们先调用fork()然后exit()，此时只有子进程在运行
现在我们来给出创建守护进程所需步骤：
编写守护进程的一般步骤步骤：
（1）在父进程中执行fork并exit推出；
（2）在子进程中调用setsid函数创建新的会话；
（3）在子进程中调用chdir函数，让根目录 ”/” 成为子进程的工作目录；
（4）在子进程中调用umask函数，设置进程的umask为0；
（5）在子进程中关闭任何不需要的文件描述符
说明：
1. 在后台运行。
为避免挂起控制终端将Daemon放入后台执行。方法是在进程中调用fork使父进程终止，让Daemon在子进程中后台执行。
if(pid=fork())
exit(0);//是父进程，结束父进程，子进程继续
2. 脱离控制终端，登录会话和进程组
有必要先介绍一下Linux中的进程与控制终端，登录会话和进程组之间的关系：进程属于一个进程组，进程组号（GID）就是进程组长的进程号（PID）。登录会话可以包含多个进程组。这些进程组共享一个控制终端。这个控制终端通常是创建进程的登录终端。
控制终端，登录会话和进程组通常是从父进程继承下来的。我们的目的就是要摆脱它们，使之不受它们的影响。方法是在第1点的基础上，调用setsid()使进程成为会话组长：
setsid();
说明：当进程是会话组长时setsid()调用失败。但第一点已经保证进程不是会话组长。setsid()调用成功后，进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离。由于会话过程对控制终端的独占性，进程同时与控制终端脱离。
3. 禁止进程重新打开控制终端
现在，进程已经成为无终端的会话组长。但它可以重新申请打开一个控制终端。可以通过使进程不再成为会话组长来禁止进程重新打开控制终端：
if(pid=fork())
exit(0);//结束第一子进程，第二子进程继续（第二子进程不再是会话组长）
4. 关闭打开的文件描述符
进程从创建它的父进程那里继承了打开的文件描述符。如不关闭，将会浪费系统资源，造成进程所在的文件系统无法卸下以及引起无法预料的错误。按如下方法关闭它们：
for(i=0;i 关闭打开的文件描述符close(i);>
5. 改变当前工作目录
进程活动时，其工作目录所在的文件系统不能卸下。一般需要将工作目录改变到根目录。对于需要转储核心，写运行日志的进程将工作目录改变到特定目录如/tmpchdir("/")
6. 重设文件创建掩模
进程从创建它的父进程那里继承了文件创建掩模。它可能修改守护进程所创建的文件的存取位。为防止这一点，将文件创建掩模清除：umask(0);
7. 处理SIGCHLD信号
处理SIGCHLD信号并不是必须的。但对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下可以简单地将SIGCHLD信号的操作设为SIG_IGN。
signal(SIGCHLD,SIG_IGN);
这样，内核在子进程结束时不会产生僵尸进程。这一点与BSD4不同，BSD4下必须显式等待子进程结束才能释放僵尸进程

[root@localhost ~]# kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

 Signal        x86/ARM     Alpha/   MIPS   PARISC   Notes
                   most others   SPARC
       ─────────────────────────────────────────────────────────────────
       SIGHUP           1           1       1       1
       SIGINT           2           2       2       2
       SIGQUIT          3           3       3       3
       SIGILL           4           4       4       4
       SIGTRAP          5           5       5       5
       SIGABRT          6           6       6       6
       SIGIOT           6           6       6       6
       SIGBUS           7          10      10      10
       SIGEMT           -           7       7      -
       SIGFPE           8           8       8       8
       SIGKILL          9           9       9       9
       SIGUSR1         10          30      16      16
       SIGSEGV         11          11      11      11
       SIGUSR2         12          31      17      17
       SIGPIPE         13          13      13      13
       SIGALRM         14          14      14      14
       SIGTERM         15          15      15      15
       SIGSTKFLT       16          -       -        7
       SIGCHLD         17          20      18      18
       SIGCLD           -          -       18      -
       SIGCONT         18          19      25      26
       SIGSTOP         19          17      23      24
       SIGTSTP         20          18      24      25
       SIGTTIN         21          21      26      27
       SIGTTOU         22          22      27      28
       SIGURG          23          16      21      29
       SIGXCPU         24          24      30      12
       SIGXFSZ         25          25      31      30
       SIGVTALRM       26          26      28      20
       SIGPROF         27          27      29      21
       SIGWINCH        28          28      20      23
       SIGIO           29          23      22      22
       SIGPOLL                                            Same as SIGIO
       SIGPWR          30         29/-     19      19
       SIGINFO          -         29/-     -       -
       SIGLOST          -         -/29     -       -
       SIGSYS          31          12      12      31
       SIGUNUSED       31          -       -       31

列表中，编号为1 ~ 31的信号为传统UNIX支持的信号，是不可靠信号(非实时的)，编号为32 ~ 63的信号是后来扩充的，称做可靠信号(实时信号)。不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号丢失，而后者不会。
下面我们对编号小于SIGRTMIN的信号进行讨论。
1) SIGHUP
本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。
登录Linux时，系统会分配给登录用户一个终端(Session)。在这个终端运行的所有程序，包括前台进程组和后台进程组，一般都属于这个Session。当用户退出Linux登录时，前台进程组和后台有对终端输出的进程将会收到SIGHUP信号。这个信号的默认操作为终止进程，因此前台进 程组和后台有终端输出的进程就会中止。不过可以捕获这个信号，比如wget能捕获SIGHUP信号，并忽略它，这样就算退出了Linux登录，wget也 能继续下载。
此外，对于与终端脱离关系的守护进程，这个信号用于通知它重新读取配置文件。
2) SIGINT
程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出，用于通知前台进程组终止进程。
3) SIGQUIT
和SIGINT类似, 但由QUIT字符(通常是Ctrl-\)来控制. 进程在因收到SIGQUIT退出时会产生core文件, 在这个意义上类似于一个程序错误信号。
4) SIGILL
执行了非法指令. 通常是因为可执行文件本身出现错误, 或者试图执行数据段. 堆栈溢出时也有可能产生这个信号。
5) SIGTRAP
由断点指令或其它trap指令产生. 由debugger使用。
6) SIGABRT
调用abort函数生成的信号。
7) SIGBUS
非法地址, 包括内存地址对齐(alignment)出错。比如访问一个四个字长的整数, 但其地址不是4的倍数。它与SIGSEGV的区别在于后者是由于对合法存储地址的非法访问触发的(如访问不属于自己存储空间或只读存储空间)。
8) SIGFPE
在发生致命的算术运算错误时发出. 不仅包括浮点运算错误, 还包括溢出及除数为0等其它所有的算术的错误。
9) SIGKILL
用来立即结束程序的运行. 本信号不能被阻塞、处理和忽略。如果管理员发现某个进程终止不了，可尝试发送这个信号。
10) SIGUSR1
留给用户使用
11) SIGSEGV
试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据.
12) SIGUSR2
留给用户使用
13) SIGPIPE
管道破裂。这个信号通常在进程间通信产生，比如采用FIFO(管道)通信的两个进程，读管道没打开或者意外终止就往管道写，写进程会收到SIGPIPE信号。此外用Socket通信的两个进程，写进程在写Socket的时候，读进程已经终止。
14) SIGALRM
时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使用该信号.
15) SIGTERM
程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出，shell命令kill缺省产生这个信号。如果进程终止不了，我们才会尝试SIGKILL。
17) SIGCHLD
子进程结束时, 父进程会收到这个信号。
如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程来接管)。
18) SIGCONT
让一个停止(stopped)的进程继续执行. 本信号不能被阻塞. 可以用一个handler来让程序在由stopped状态变为继续执行时完成特定的工作. 例如, 重新显示提示符...
19) SIGSTOP
停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略.
20) SIGTSTP
停止进程的运行, 但该信号可以被处理和忽略. 用户键入SUSP字符时(通常是Ctrl-Z)发出这个信号
21) SIGTTIN
当后台作业要从用户终端读数据时, 该作业中的所有进程会收到SIGTTIN信号. 缺省时这些进程会停止执行.
22) SIGTTOU
类似于SIGTTIN, 但在写终端(或修改终端模式)时收到.
23) SIGURG
有"紧急"数据或out-of-band数据到达socket时产生.
24) SIGXCPU
超过CPU时间资源限制. 这个限制可以由getrlimit/setrlimit来读取/改变。
25) SIGXFSZ
当进程企图扩大文件以至于超过文件大小资源限制。
26) SIGVTALRM
虚拟时钟信号. 类似于SIGALRM, 但是计算的是该进程占用的CPU时间.
27) SIGPROF
类似于SIGALRM/SIGVTALRM, 但包括该进程用的CPU时间以及系统调用的时间.
28) SIGWINCH
窗口大小改变时发出.
29) SIGIO
文件描述符准备就绪, 可以开始进行输入/输出操作.
30) SIGPWR
Power failure
31) SIGSYS
非法的系统调用。
在以上列出的信号中，程序不可捕获、阻塞或忽略的信号有：SIGKILL,SIGSTOP
不能恢复至默认动作的信号有：SIGILL,SIGTRAP
默认会导致进程流产的信号有：SIGABRT,SIGBUS,SIGFPE,SIGILL,SIGIOT,SIGQUIT,SIGSEGV,SIGTRAP,SIGXCPU,SIGXFSZ
默认会导致进程退出的信号有：SIGALRM,SIGHUP,SIGINT,SIGKILL,SIGPIPE,SIGPOLL,SIGPROF,SIGSYS,SIGTERM,SIGUSR1,SIGUSR2,SIGVTALRM
默认会导致进程停止的信号有：SIGSTOP,SIGTSTP,SIGTTIN,SIGTTOU
默认进程忽略的信号有：SIGCHLD,SIGPWR,SIGURG,SIGWINCH
此外，SIGIO在SVR4是退出，在4.3BSD中是忽略；SIGCONT在进程挂起时是继续，否则是忽略，不能被阻塞

1. 自定义信号最好从 SIGRTMIN 开始，但最好保留前几个。比如SIGRTMIN+10。
2. 用kill(0,signo)发送自定义信号时，本进程和所有子进程(通过exec等方式启动的)都必须有对应的处理函数，否则所有进程都会退出

<?php

ini_set('display_errors', 'on');
// Reporting all.
error_reporting(E_ALL);
// JIT is not stable, temporarily disabled.
ini_set('pcre.jit', 0);

$opts = array(
    'socket' => array(
        'backlog' => 102400, //成功建立socket连接的等待个数
    ),
);
$context = stream_context_create($opts);

//开启多端口监听,并且实现负载均衡
stream_context_set_option($context, 'socket', 'so_reuseport', 1);
stream_context_set_option($context, 'socket', 'so_reuseaddr', 1);
$socket_base = stream_socket_server('tcp://127.0.0.1:9800', $errno, $errstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context);

$socket = socket_import_stream($socket_base);
socket_set_option($socket, \SOL_SOCKET, \SO_KEEPALIVE, 1);
socket_set_option($socket, \SOL_TCP, \TCP_NODELAY, 1);

stream_set_blocking($socket_base, false);//非阻塞

//stream_socket_accept 本身就是阻塞的
$clientSocket = stream_socket_accept($socket_base, -1);

while (is_resource($clientSocket) && !feof($clientSocket)) {

    stream_set_blocking($clientSocket, false);

    $buffer = fread($clientSocket, 1000);

        print_r($buffer);
        if (empty($buffer)) {
            if (is_resource($clientSocket) && feof($clientSocket)) {
                //触发关闭事件
                    fclose($clientSocket);
            }
        }else{
            $http_resonse = "HTTP/1.1 200 OK\r\n";
            $http_resonse .= "Content-Type: text/html;charset=UTF-8\r\n";
            $http_resonse .= "Connection: keep-alive\r\n"; //连接保持
            $http_resonse .= "Server: php socket server\r\n";
            $http_resonse .= "Content-length: " . strlen($buffer) . "\r\n\r\n";
            $http_resonse .= $buffer;
            fwrite($clientSocket, $http_resonse);
        }
}

fclose($socket_base);

<?php
ini_set('display_errors', 'on');
// Reporting all.
error_reporting(E_ALL);
// JIT is not stable, temporarily disabled.
ini_set('pcre.jit', 0);

$opts = array(
    'socket' => array(
        'backlog' => 102400, //成功建立socket连接的等待个数
    ),
);
$context = stream_context_create($opts);

//开启多端口监听,并且实现负载均衡
stream_context_set_option($context, 'socket', 'so_reuseport', 1);
stream_context_set_option($context, 'socket', 'so_reuseaddr', 1);

$socket_base = stream_socket_server('tcp://127.0.0.1:9800', $errno, $errstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context);

$socket = socket_import_stream($socket_base);
socket_set_option($socket, \SOL_SOCKET, \SO_KEEPALIVE, 1);
socket_set_option($socket, \SOL_TCP, \TCP_NODELAY, 1);

stream_set_blocking($socket_base, false);//非阻塞

function rw($fd,$event){
    stream_set_blocking($fd, false);
    $buffer = fread($fd, 1000);
    print_r($buffer);
    if(empty($buffer)){
        // fclose($fd);
    }else{
        $http_resonse = "HTTP/1.1 200 OK\r\n";
            $http_resonse .= "Content-Type: text/html;charset=UTF-8\r\n";
            $http_resonse .= "Connection: keep-alive\r\n"; //连接保持
            $http_resonse .= "Server: php socket \r\n";
            $http_resonse .= "Content-length: " . strlen($buffer) . "\r\n\r\n";
            $http_resonse .= $buffer;
            fwrite($fd, $http_resonse);
    }
}

function accept($fd,$event){
    //stream_socket_accept 本身就是阻塞的
    $clientSocket = stream_socket_accept($fd, 0);
    stream_set_blocking($clientSocket, false);

    $base = new EventBase();
    $event = new Event($base, $clientSocket, Event::READ | Event::WRITE | Event::PERSIST, 'rw');
    $event->add();
    $base->loop();
}

$base = new EventBase();
$event = new Event($base, $socket_base, Event::READ | Event::PERSIST, 'accept');
$event->add();

$base->loop();

fclose($base);

<?php

class Worker
{
    //监听socket
    protected $socket = NULL;
    //连接事件回调
    public $onConnect = NULL;
    public $reusePort = 1;
    //接收消息事件回调
    public $onMessage = NULL;
    public $workerNum = 10; //子进程个数
    public $allSocket; //存放所有socket
    public $addr;
    protected $worker_pid; //子进程pid
    protected $master_pid;//主进程id

    public function __construct($socket_address)
    {
        //监听地址+端口
        $this->addr = $socket_address;
        $this->master_pid = posix_getpid();
    }

    public function start()
    {
        //获取配置文件
        $this->fork($this->workerNum);
        $this->monitorWorkers(); //监视程序,捕获信号,监视worker进程
    }


    public function signalHandler($sigo)
    {
        switch ($sigo) {
            case SIGUSR1:
                $this->reload();
                echo "收到重启信号";
                break;
        }

    }

    public function fork($worker_num)
    {
        for ($i = 1; $i < $worker_num; $i++) {
            $pid = pcntl_fork(); //创建成功会返回子进程id
            if ($pid < 0) {
                exit('创建失败');
            } else if ($pid > 0) {
                //父进程空间，返回子进程id
                $this->worker_pid[] = $pid;
            } else { //返回为0子进程空间
                $this->accept();//子进程负责接收客户端请求
                exit;
            }
        }
        //放在父进程空间，结束的子进程信息，阻塞状态

    }

    /**
     * 捕获信号
     * 监视worker进程.拉起进程
     */
    public function monitorWorkers()
    {
        //注册信号事件回调,是不会自动执行的
        // reload
        pcntl_signal(SIGUSR1, array($this, 'signalHandler'), false); //重启woker进程信号

        while (1) {
            // 当发现信号队列,一旦发现有信号就会触发进程绑定事件回调
            \pcntl_signal_dispatch();
            $status = 0;
            $pid = pcntl_wait($status, \WUNTRACED); //当信号到达之后就会被中断
            \pcntl_signal_dispatch();
            //进程重启的过程当中会有新的信号过来,如果没有调用pcntl_signal_dispatch,信号不会被处理

        }
    }

    public function accept()
    {
        $opts = array(
            'socket' => array(
                'backlog' => 10240, //成功建立socket连接的等待个数
            ),
        );
        $context = stream_context_create($opts);
        //开启多端口监听,并且实现负载均衡
        stream_context_set_option($context, 'socket', 'so_reuseport', 1);
        stream_context_set_option($context, 'socket', 'so_reuseaddr', 1);
        $this->socket = stream_socket_server($this->addr, $errno, $errstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context);

        stream_set_blocking($this->socket, false);//非阻塞
        $base = new EventBase();
        $ss = $this->socket;
        //监听服务端的socket
        $event = new  Event($base, $ss, Event::PERSIST | Event::READ | Event::WRITE, function ($ss) {

            $clientSocket = stream_socket_accept($ss);
            //触发事件的连接的回调
            if (!empty($clientSocket) && is_callable($this->onConnect)) {
                call_user_func($this->onConnect, $clientSocket);
            }
            $base = new EventBase();
            //监听客户端socket
            $event = new  Event($base, $clientSocket, Event::PERSIST | Event::READ | Event::WRITE, function ($clientSocket) {
                $buffer = fread($clientSocket, 65535);
                if (empty($buffer)) {
                    if (!is_resource($clientSocket) || feof($clientSocket)) {
                        //触发关闭事件
                        fclose($clientSocket);
                    }
                }
                //正常读取到数据,触发消息接收事件,响应内容
                if (!empty($buffer) && is_callable($this->onMessage)) {
                    call_user_func($this->onMessage,