socket_accept(Socket $socket): Socket|false

// 创建 TCP 套接字
$server_socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
// 将套接字绑定到指定的主机地址和端口上
socket_bind($server_socket, "0.0.0.0", 8080);
// 设置为监听套接字
socket_listen($server_socket);

printf("master[%d] running\n", posix_getpid());

for ($i = 0; $i < 5; $i++) {
    $pid = pcntl_fork();
    if ($pid < 0) {
        exit('fork 失败');
    } else if ($pid == 0) {
        // 这里是子进程
        $pid = posix_getpid();
        printf("worker[%d] running\n", $pid);

        // while true 是为了处理完一个连接之后，可以继续处理下一个连接
        while (true) {
            // 由于我们刚刚创建的 $server 是阻塞 IO，
            // 所以代码运行到这的时候会阻塞住，会将 CPU 让出去，
            // 直到有客户端来连接
            $conn_socket = socket_accept($server_socket);
            if (!$conn_socket) {
                printf("worker[%d] 接收新连接失败，原因：%s\n", $pid, socket_last_error($conn_socket));
                continue;
            }

            // 获取客户端地址及端口号
            socket_getpeername($conn_socket, $address, $port);
            printf("worker[%d] 接收新连接成功：%s:%d\n", $pid, $address, $port);
            // 关闭客户端连接
            socket_close($conn_socket);
        }
    }
    // 这里是父进程
}

// 父进程等待子进程退出，回收资源
while (true) {
    // 为待处理的信号调用信号处理程序。
    \pcntl_signal_dispatch();
    // 暂停当前进程的执行，直到一个子进程退出，或者直到一个信号被传递。
    $pid = \pcntl_wait($status, WUNTRACED);
    // 再次调用待处理信号的信号处理程序。
    \pcntl_signal_dispatch();

    if ($pid > 0) {
        printf("worker[%d] 退出\n", $pid);
    }
}

socket_select(
    array|null &$read,
    array|null &$write,
    array|null &$except,
    int|null $seconds,
    int $microseconds = 0
): int|false

// 创建 TCP 套接字
$server_socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
// 将套接字绑定到指定的主机地址和端口上
socket_bind($server_socket, "0.0.0.0", 8080);
// 设置为监听套接字
socket_listen($server_socket);
// 设置为非阻塞
socket_set_nonblock($server_socket);

printf("master[%d] running\n", posix_getpid());

for ($i = 0; $i < 5; $i++) {
    $pid = pcntl_fork();
    if ($pid < 0) {
        exit('fork 失败');
    } else if ($pid == 0) {
        // 这里是子进程
        $pid = posix_getpid();
        printf("worker[%d] running\n", $pid);

        // while true 是为了处理完一个连接之后，可以继续处理下一个连接
        while (true) {
            // 将监听套接字放入可读事件的套接字数组中，
            // 表示我们需要等待监听套接字上的可读事件，
            // 监听套接字发生可读事件说明有客户端连接上来了。
            $reads = [$server_socket];
            // 可写事件和异常事件我们不关心，设置为空数组即可。
            $writes = $excepts = [];
            // 超时时间设置为 NULL，表示一直阻塞等待，直到有事件发生。
            $num = socket_select($reads, $writes, $excepts, NULL);

            printf("worker[%d] wakeup，num：%d\n", $pid, $num);

            $conn_socket = socket_accept($server_socket);
            if (!$conn_socket) {
                printf("worker[%d] 接收新连接失败\n", $pid);
                continue;
            }

            // 获取客户端地址及端口号
            socket_getpeername($conn_socket, $address, $port);
            printf("worker[%d] 接收新连接成功：%s:%d\n", $pid, $address, $port);
            // 关闭客户端连接
            socket_close($conn_socket);
        }
    }
    // 这里是父进程
}

// 父进程等待子进程退出，回收资源
while (true) {
    // 为待处理的信号调用信号处理程序。
    \pcntl_signal_dispatch();
    // 暂停当前进程的执行，直到一个子进程退出，或者直到一个信号被传递。
    $pid = \pcntl_wait($status, WUNTRACED);
    // 再次调用待处理信号的信号处理程序。
    \pcntl_signal_dispatch();

    if ($pid > 0) {
        printf("worker[%d] 退出\n", $pid);
    }
}

// 是否开启 accept 锁，
// 开启则需要抢锁，以防惊群，默认是关闭的。
if (ngx_use_accept_mutex) {
    if (ngx_accept_disabled > 0) {
        // ngx_accept_disabled 的值是经过算法计算出来的，
        // 当值大于 0 时，说明此进程负载过高，不再接收新连接。
        ngx_accept_disabled--;
    } else {
        // 尝试抢 accept 锁，发生错误直接返回
        if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
            return;
        }

        if (ngx_accept_mutex_held) {
            // 抢到锁，设置事件处理标识，后续事件先暂存队列中。
            flags |= NGX_POST_EVENTS;

        } else {
            // 未抢到锁，修改阻塞等待时间，使得下一次抢锁不会等待太久
            if (timer == NGX_TIMER_INFINITE
                || timer > ngx_accept_mutex_delay)
            {
                timer = ngx_accept_mutex_delay;
            }
        }
    }
}

// Nginx 支持端口复用
#if (NGX_HAVE_REUSEPORT)
    // 配置 listen 80 resuseport 时，支持多进程共用一个端口，
    // 此时可直接把监听套接字加入事件循环中，并监听可读事件。
    if (ls[i].reuseport) {
        if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
            return NGX_ERROR;
        }

        continue;
    }
#endif

    // 打开 accept_mutex 锁之后，
    // 每个 worker 进程不能直接处理监听套接字，
    // 需要在 worker 进程抢到锁之后才能将监听套接字放入自己的事件循环中。
    if (ngx_use_accept_mutex) {
        continue;
    }

// Nginx 支持 EPOLLEXCLUSIVE 标志
#if (NGX_HAVE_EPOLLEXCLUSIVE)
    // 如果 nginx 使用的是 epoll 多路复用机制，并且 worker 进程大于 1，
    // 那么就将监听套接字加入自己的事件循环中，并且设置 EPOLLEXCLUSIVE 标志。
    if ((ngx_event_flags & NGX_USE_EPOLL_EVENT)
        && ccf->worker_processes > 1)
    {
        if (ngx_add_event(rev, NGX_READ_EVENT, NGX_EXCLUSIVE_EVENT)
            == NGX_ERROR)
        {
            return NGX_ERROR;
        }

        continue;
    }
#endif

    // 未开启 accept_mutex 锁，未启动 resuseport 端口复用，不支持 EPOLLEXCLUSIVE 标志，
    // 此后监听套接字发生事件时会引发惊群问题。
    if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
        return NGX_ERROR;
    }

// source: Protocols\Http\Request.php
post()/file()
    -> parsePost()
        -> parseUploadFiles()

protected function parsePost()
{
    // rawBody() 返回的就是请求体的内容
    $body_buffer = $this->rawBody();
    // 初始化用于保存解析数据的缓存
    $this->_data['post'] = $this->_data['files'] = array();
    if ($body_buffer === '') {
        return;
    }
    // 尝试从缓存中读取
    $cacheable = static::$_enableCache && !isset($body_buffer[1024]);
    if ($cacheable && isset(static::$_postCache[$body_buffer])) {
        $this->_data['post'] = static::$_postCache[$body_buffer];
        return;
    }
    // 读取请求头中的 content-type 字段，如果请求头没有被解析过，那么也会进行解析并缓存
    $content_type = $this->header('content-type', '');
    // 尝试解析 boundary 字段，如果获取到了说明是 multipart/form-data 类型的，可能会上传文件
    if (\preg_match('/boundary="?(\S+)"?/', $content_type, $match)) {
        // $match[1] 中就是我们上面说的边界值
        // 加上 -- 得到请求体中的边界值
        $http_post_boundary = '--' . $match[1];
        $this->parseUploadFiles($http_post_boundary);
        return;
    }
    // 如果从 content-type 中匹配到了 json，比如 application/json
    // 说明请求体的数据是 JSON 格式的
    if (\preg_match('/\bjson\b/i', $content_type)) {
        $this->_data['post'] = (array) json_decode($body_buffer, true);
    } else {
        // 否则就是 application/x-www-form-urlencoded
            \parse_str($body_buffer, $this->_data['post']);
    }
    // 如果开启了缓存，就把解析结果缓存起来
    if ($cacheable) {
        static::$_postCache[$body_buffer] = $this->_data['post'];
        if (\count(static::$_postCache) > 256) {
            unset(static::$_postCache[key(static::$_postCache)]);
        }
    }
}

// 先获取请求体的内容
$http_body = $this->rawBody();
//删除末尾的结束边界值
$http_body = \substr($http_body, 0, \strlen($http_body) - (\strlen($http_post_boundary) + 4))

// 通过边界值 + \r\n 分割请求体，得到数据块数组
$boundary_data_array = \explode($http_post_boundary . "\r\n", $http_body);
if ($boundary_data_array[0] === '') {
    unset($boundary_data_array[0]);
};

foreach ($boundary_data_array as $boundary_data_buffer) {
    list($boundary_header_buffer, $boundary_value) = \explode("\r\n\r\n", $boundary_data_buffer, 2);
    // 去除 $boundary_value 末尾的 \r\n
    $boundary_value = \substr($boundary_value, 0, -2);
    $key++;
}

foreach (\explode("\r\n", $boundary_header_buffer) as $item) {
    list($header_key, $header_value) = \explode(": ", $item);
    $header_key = \strtolower($header_key);

    switch ($header_key) {
        case "content-disposition":
            // 匹配到了 filename 说明是文件数据
            if (\preg_match('/name="(.*?)"; filename="(.*?)"/i', $header_value, $match)) {
                $error = 0;
                $tmp_file = '';
                // 获取文件大小
                $size = \strlen($boundary_value);
                // 获取上传临时目录
                $tmp_upload_dir = HTTP::uploadTmpDir();
                if (!$tmp_upload_dir) {
                    $error = UPLOAD_ERR_NO_TMP_DIR;
                } else {
                    // 使用 tempnam 函数在临时目录下创建一个唯一文件名的临时文件
                    $tmp_file = \tempnam($tmp_upload_dir, 'workerman.upload.');
                    // 文件创建成功后，将数据块的值写入到文件中
                    if ($tmp_file === false || false == \file_put_contents($tmp_file, $boundary_value)) {
                        $error = UPLOAD_ERR_CANT_WRITE;
                    }
                }
                // 格式化上传的文件信息
                $files[$key] = array(
                    'key' => $match[1], // 表单中的字段名
                    'name' => $match[2], // 文件名称
                    'tmp_name' => $tmp_file, // 临时文件的完整路径
                    'size' => $size, // 文件大小
                    'error' => $error // 错误
                );
                break;
            } else {
                // 未匹配到 filename 说明是 POST 字段，需要解析 $_POST.
                if (\preg_match('/name="(.*?)"$/', $header_value, $match)) {
                    $this->_data['post'][$match[1]] = $boundary_value;
                }
            }
            break;
        case "content-type":
            // 添加文件类型
            $files[$key]['type'] = \trim($header_value);
            break;
    }
}

HTTP 消息是服务器和客户端之间交换数据的方式。有两种类型的消息︰ 请求（requests）--由客户端发送用来触发一个服务器上的动作；响应（responses）--来自服务器的应答。

HTTP消息由采用 ASCII 编码的多行文本构成。

GET /index.html?name=her-cat HTTP/1.1\r\n
Host: 127.0.0.1:8081\r\n
Connection: keep-alive\r\n
Accept: text/html\r\n
\r\n

GET /index.html?name=her-cat HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nAccept: text/html\r\n\r\n

// source: Workerman/Protocols/Http.php

/**
 * 返回值为 0 有两种情况：
 *   1) 如果断开了连接，表示不再接收数据
 *   2) 如果未断开连接，表示需要继续接收数据
 *
 * 返回值大于 0 表示 HTTP 协议包的大小或请求体的大小
 *
 */
public static function input($recv_buffer, TcpConnection $connection)
{
    // 判断收到的数据中是否包含两个连续的 CRLF
    $crlf_pos = \strpos($recv_buffer, "\r\n\r\n");
    // false 说明不包含，需要继续接收数据
    if (false === $crlf_pos) {
        // 判断请求头数据长度是否超限
        if ($recv_len = \strlen($recv_buffer) >= 16384) {
            // 超限则断开连接并响应 413 状态码
            $connection->close("HTTP/1.1 413 Request Entity Too Large\r\n\r\n");
            return 0;
        }
        return 0;
    }

    // 请求头长度，+4 是将两个 CRLF 的长度算上
    $head_len = $crlf_pos + 4;
    // 请求方式
    $method = \strstr($recv_buffer, ' ', true);

    if ($method === 'GET' || $method === 'OPTIONS' || $method === 'HEAD' || $method === 'DELETE') {
        // 这几种方法不需要接收请求体，直接返回请求头长度
        return $head_len;
    } else if ($method !== 'POST' && $method !== 'PUT') {
        // 非法的请求方式
        $connection->close("HTTP/1.1 400 Bad Request\r\n\r\n", true);
        return 0;
    }

    // 到这里说明本次是 POST 或 PUT 请求，在后面的 POST 请求中讲解。
}

POST / HTTP/1.1\r\n
Host: 127.0.0.1:8080\r\n
Connection: keep-alive\r\n
Content-Length: 28\r\n
Accept: text/html\r\n
Content-Type: application/x-www-form-urlencoded\r\n
\r\n
name=her-cat&password=123456

public static function input($recv_buffer, TcpConnection $connection)
{
    ...上面解析 GET 请求的逻辑...

    // 获取请求头的内容
    $header = \substr($recv_buffer, 0, $crlf_pos);
    // 请求体的长度
    $length = false;

    // 解析请求体的长度
    if ($pos = \strpos($header, "\r\nContent-Length: ")) {
        $length = $head_len + (int)\substr($header, $pos + 18, 10);
    } else if (\preg_match("/\r\ncontent-length: ?(\d+)/i", $header, $match)) {
        $length = $head_len + $match[1];
    }

    if ($length !== false) {
        // 返回请求体的长度
        return $length;
    }

    // 未解析到 Content-Length 字段则断开连接并响应 400 状态码
    $connection->close("HTTP/1.1 400 Bad Request\r\n\r\n", true);
    return 0;
}

$form_params = [
    '&name' => 'her-cat=',
    'password' => '123456&',
];

$data = [];
foreach ($form_params as $name => $value) {
    $data[] = urlencode($name).'='.urlencode($value);
}

$body = implode('&', $data);

echo $body;

// 输出：%26name=her-cat%3D&password=123456%26

POST / HTTP/1.1\r\n
Host: 127.0.0.1:8080\r\n
Connection: keep-alive\r\n
Content-Length: 243\r\n
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarySyX8l4XxjtjHAusG\r\n
\r\n
------WebKitFormBoundarySyX8l4XxjtjHAusG\r\n
Content-Disposition: form-data; name="name"\r\n
\r\n
her-cat\r\n
------WebKitFormBoundarySyX8l4XxjtjHAusG\r\n
Content-Disposition: form-data; name="file"; filename="code.txt"
Content-Type: text/plain\r\n
\r\n
hello her-cat\r\n
------WebKitFormBoundarySyX8l4XxjtjHAusG--\r\n

  ----WebKitFormBoundarySyX8l4XxjtjHAusG // 请求头中的边界值
------WebKitFormBoundarySyX8l4XxjtjHAusG // 请求体中的边界值

/**
 * 头部长度
 */
const HEADER_LEN = 16;

/**
 * 协议版本
 */
const PROTOCOL_VERSION = 2;

/**
 * 魔法数字，设置为 1 即可
 */
const MAGIC_NUMBER = 1;

public static function pack($opcode, $payload = '')
{
    $packetLen = static::HEADER_LEN;
    if (!empty($payload)) {
        $packetLen += strlen($payload);
    }

    return pack('NnnNN', $packetLen, static::HEADER_LEN, static::PROTOCOL_VERSION, $opcode, static::MAGIC_NUMBER).$payload
}

return sprintf(
    '%s%s%s%s%s%s',
    pack('N', $packetLen),
    pack('n', static::HEADER_LEN),
    pack('n', static::PROTOCOL_VERSION),
    pack('N', $opcode),
    pack('N', static::MAGIC_NUMBER),
    $payload
);

$data = pack('Nnn', 2021, 3, 31);

var_dump($data);

$arr = unpack('Nyear/nmonth/nday', $data);

var_dump($arr);

// 输出：

string(8) "\000\000�\000\000"
array(3) {
  'year' => int(2021)
  'month' =>int(3)
  'day' => int(31)
}

public static function unpack($data)
{
    if (empty($data)) {
        return [];
    }

    return unpack('Npacket_len/nheader_len/nprotocol_version/Nopcode/Nmagic_number/a*payload', $data);
}

const PACKET_HEADER_LEN = 16;
const PACKET_PROTOCOL_VERSION = 2;
const PACKET_MAGIC_NUMBER = 1;

class Packet {
    static pack(opcode, payload = '') {
        let packet_len = PACKET_HEADER_LEN;
        if (payload.length > 0) {
            packet_len += payload.length;
        }

        let buffer = Buffer.alloc(packet_len);

        buffer.writeInt32BE(packet_len, 0);
        buffer.writeInt16BE(PACKET_HEADER_LEN, 4);
        buffer.writeInt16BE(PACKET_PROTOCOL_VERSION, 6);
        buffer.writeInt32BE(opcode, 8);
        buffer.writeInt32BE(PACKET_MAGIC_NUMBER, 12);

        if (payload.length > 0) {
            buffer.write(payload, PACKET_HEADER_LEN, payload.length);
        }

        return buffer;
    }

    static unpack(data) {
        let buffer = Buffer.from(data);

        return {
            packet_len: buffer.readInt32BE(0),
            header_len: buffer.readInt16BE(4),
            version: buffer.readInt16BE(6),
            opcode: buffer.readInt32BE(8),
            magic_number: buffer.readInt32BE(12),
            data: buffer.slice(PACKET_HEADER_LEN),
        };
    }
}

 const CHAT_CONFIG_URL = 'https://api.live.bilibili.com/room/v1/Danmu/getConf?room_id=%d';

/**
 * 获取直播间配置
 * @param $room_id
 * @return mixed
 * @throws \Exception
 */
public static function getChatConfig($room_id)
{
    if (isset(static::$roomConfigs[$room_id])) {
        return static::$roomConfigs[$room_id];
    }

    $response = file_get_contents(sprintf(self::CHAT_CONFIG_URL, $room_id));
    $response = json_decode($response, true);

    if (empty($response) || $response['code'] != 0) {
        throw new \Exception("Get chat conf failed, reason: {$response['msg']}");
    }

    static::$roomConfigs[$room_id] = $response['data'];

    return $response['data'];
}

{
    "code":0,
    "msg":"ok",
    "message":"ok",
    "data":{
        "refresh_row_factor":0.125,
        "refresh_rate":100,
        "max_delay":5000,
        "port":2243,
        "host":"broadcastlv.chat.bilibili.com",
        "token":"pMF5ippgZMpHIHzTsfKHp9YyqmW3yEfuIuL3pXSMXJ8_9UFN-qSRIPTRxNjpNOr5HQ2-ajI0RcSQkMud2_-lMLoEN92k1glp9fOslshF5SFDqDhlEJRAvUwezoyz72ZdNh-sSqHMPsGOJGMOXZmRNA"
    }
}

{
  "uid": "0 表示未登录，否则为用户ID",
  "roomid": "房间ID",
  "protover": "协议版本号",
  "platform": "平台",
  "clientver": "客户端版本号",
  "token": "接口返回的 token"
}

public static function getAuthenticatePacket($room_id, $token = null)
{
    if (empty($token)) {
        $token = static::getChatConfig($room_id)['token'];
    }

    $payload = \json_encode([
        'uid' => 0,
        'roomid' => $room_id,
        'protover' => Packet::PROTOCOL_VERSION,
        'platform' => 'web',
        'token' => $token,
    ]);

    return Packet::pack(Opcode::AUTHENTICATION, $payload);
}

\000\000\000�\000\000\000\000\000\000\000\000{"uid":0,"roomid":22590309,"protover":2,"platform":"web","token":"pMF5ippgZMpHIHzTsfKHp9YyqmW3yEfuIuL3pXSMXJ8_9UFN-qSRIPTRxNjpNOr5HQ2-ajI0RcSQkMud2_-lMLoEN92k1glp9fOslshF5SFDqDhlEJRAvUwezoyz72ZdNh-sSqHMPsGOJGMOXZmRNA"}

array(6) {
  'packet_len' => int(26)
  'header_len' => int(16)
  'protocol_version' => int(2)
  'opcode' => int(8)
  'magic_number' => int(1)
  'payload' => string(10) "{"code":0}"
}

public static function getHeartBeatPacket()
{
    return Packet::pack(Opcode::CLIENT_HEARTBEAT);
}

$room_id = 22590309;
/* 获取直播间配置 */
$config = BilibiliBarrage::getChatConfig($room_id);

/* 创建异步 TCP 连接对象 */
$conn = new AsyncTcpConnection("tcp://{$config['host']}:{$config['port']}");

$conn->onConnect = function(TcpConnection $conn) use ($room_id, $config) {
    $packet = BilibiliBarrage::getAuthenticatePacket($room_id, $config['token']);
    /* 发送认证包 */
    $result = $conn->send($packet, true);
    if (!$result) {
        Worker::safeEcho("发送认证包失败\n");
        return;
    }

    /* 开启定时任务 */
    Timer::add(BilibiliBarrage::HEART_BEAT_INTERVAL, function (TcpConnection $conn) {
        /* 发送心跳包 */
        $conn->send(BilibiliBarrage::getHeartBeatPacket(), true);
    }, [$conn]);
};

$conn->onMessage = function($conn, $data) {
    $packet = Packet::unpack($data);
    /* 通过 opcode 判断消息类型 */
    switch ($packet['opcode']) {
        case Opcode::POPULARITY_VALUE:
            Worker::safeEcho(sprintf("人气值: %d\n", Packet::parsePayload($packet['opcode'], $packet['payload'])));
            break;
        case Opcode::CMD:
            /* 解析数据 */
            $payload = Packet::parsePayload($packet['opcode'], $packet['payload']);
            if (empty($payload)) {
                break;
            }

            switch ($payload['cmd']) {
                case 'INTERACT_WORD':
                    Worker::safeEcho("{$payload['data']['uname']} 进入直播间\n");
                    break;
                case 'DANMU_MSG':
                    Worker::safeEcho("{$payload['info'][2][1]}: {$payload['info'][1]}\n");
                    break;
                case 'SEND_GIFT':
                    Worker::safeEcho("{$payload['data']['uname']} {$payload['data']['action']} {$payload['data']['giftName']}\n");
                    break;
                case 'COMBO_SEND':
                    Worker::safeEcho("{$payload['data']['uname']} {$payload['data']['action']} {$payload['data']['gift_name']} [combo]\n");
                    break;
                /* 更多命令查看 \App\CMD.php 文件 */
            }
            break;
        case Opcode::SERVER_HEARTBEAT:
            Worker::safeEcho("加入房间成功\n");
            break;
        default:
            /* 未知的 opcode 可以打印 packet */
            // var_dump($packet);
            break;
    }
};

Where is the problem?! I reboot the server and it is the first time I want to run workerman

php index.php start -d
The result is

Workerman[index.php] start in DAEMON mode
Workerman[index.php] already running

// Start file.
$backtrace        = \debug_backtrace();
static::$_startFile = $backtrace[\count($backtrace) - 1]['file'];

// 生成文件名
$unique_prefix = \str_replace('/', '_', static::$_startFile);

// 保存记录主进程 PID 的文件路径
if (empty(static::$pidFile)) {
    static::$pidFile = __DIR__ . "/../$unique_prefix.pid";
}

// 设置主进程名称（记住这个进程名称，后面会用到）
static::setProcessTitle(static::$processTitle . ': master process  start_file=' . static::$_startFile);

// 获取主进程的 PID，如果文件不存在或者不是一个正常的文件则返回 0
$master_pid      = \is_file(static::$pidFile) ? \file_get_contents(static::$pidFile) : 0;

// 如果 PID 存在就给它发送一个信号 `0`，信号量 `0` 类似于 ping，用于检测进程是否存活
// 然后判断当前进程 PID 是否不等于文件中记录的 PID（不相等说明 Workerman 已经在运行中，但是又再次执行命令了）
$master_is_alive = $master_pid && \posix_kill($master_pid, 0) && \posix_getpid() !== $master_pid;
if ($master_is_alive) {
    // 如果主进程存活并且执行的命令为 start，提示 Workerman 正在运行中并退出
    if ($command === 'start') {
        static::log("Workerman[$start_file] already running");
        exit;
    }
} elseif ($command !== 'start' && $command !== 'restart') {
    // 如果主进程未存活且执行的命令不是 start 或 restart，则提示 Workerman 未运行并退出
    static::log("Workerman[$start_file] not run");
    exit;
}

protected static function saveMasterPid()
{
    // 非 Linux 系统不保存 PID
    if (static::$_OS !== \OS_TYPE_LINUX) {
        return;
    }

    // 获取主进程的 PID
    static::$_masterPid = \posix_getpid();

    // 将主进程的 PID 写入到文件中
    if (false === \file_put_contents(static::$pidFile, static::$_masterPid)) {
        throw new Exception('can not save pid to ' . static::$pidFile);
    }
}

protected static function exitAndClearAll()
{
    foreach (static::$_workers as $worker) {
        $socket_name = $worker->getSocketName();
        if ($worker->transport === 'unix' && $socket_name) {
            list(, $address) = \explode(':', $socket_name, 2);
            @\unlink($address);
        }
    }
    // 删除 PID 文件
    @\unlink(static::$pidFile);
    static::log("Workerman[" . \basename(static::$_startFile) . "] has been stopped");
    if (static::$onMasterStop) {
        \call_user_func(static::$onMasterStop);
    }
    // 退出进程
    exit(0);
}

if [ $(php start.php status 2>/dev/null|grep "PROCESS STATUS"|wc -l) -eq 0 ]; then
  # clean up old run, remove pid file or run a stop command?
  php start.php stop
  php start.php start -d
fi

// Get master process PID.
$master_pid      = \is_file(static::$pidFile) ? \file_get_contents(static::$pidFile) : 0;
// Master is still alive?
if (static::checkMasterIsAlive($master_pid)) {
    if ($command === 'start') {
        static::log("Workerman[$start_file] already running");
        exit;
    }
}


/**
 * Check master process is alive
 *
 * @param $master_pid
 * @return bool
 */
protected static function checkMasterIsAlive($master_pid)
{
    if (empty($master_pid)) {
        return false;
    }

    $master_is_alive = $master_pid && \posix_kill($master_pid, 0) && \posix_getpid() !== $master_pid;
    if (!$master_is_alive) {
        return false;
    }

    // Master process will send SIGUSR2 signal to all child processes.
    \posix_kill($master_pid, SIGUSR2);
    // Sleep 1 second.
    \sleep(1);

    return stripos(static::formatStatusData(), 'PROCESS STATUS') !== false;
}

Fixed: #125

There is a problem:
if another process starts and the pid is the same as the workerman's old pid, it will receive the SIGUSR2 signal.

Thank you for your pr.

There is a problem:
if another process starts and the pid is the same as the workerman's old pid, it will receive the SIGUSR2 signal.

If the PR is merged, some commands will be delayed by one second.
I think a better way is to read /proc/PID information to determine whether it is a PHP process or a workerman process.

/**
 * Set process name.
 *
 * @param string $title
 * @return void
 */
protected static function setProcessTitle($title)
{
    // 设置一个空的错误处理函数，避免提示 PHP 错误
    \set_error_handler(function(){});
    // >=php 5.5
    if (\function_exists('cli_set_process_title')) {
        \cli_set_process_title($title);
    } // Need proctitle when php<=5.5 .
    elseif (\extension_loaded('proctitle') && \function_exists('setproctitle')) {
        \setproctitle($title);
    }
    // 还原错误处理函数
    \restore_error_handler();
}

protected static function checkMasterIsAlive($master_pid)
{
    if (empty($master_pid)) {
        return false;
    }

    // 检查进程是否存活
    $master_is_alive = $master_pid && \posix_kill($master_pid, 0) && \posix_getpid() !== $master_pid;
    if (!$master_is_alive) {
        return false;
    }

    // 到了这里说明进程是存活的，但是不能保证这个进程是 Workerman 进程
    // 需要读取进程信息才能确定，有任何一个步骤导致不能获取进程信息都要返回 true
    // 因为根据上面的检测结果，进程是存活的

    $cmdline = "/proc/{$master_pid}/cmdline";

    // 进程信息不可读或设置的进程名为空
    if (!is_readable($cmdline) || empty(static::$processTitle)) {
        return true;
    }
    
    $content = file_get_contents($cmdline);
    // 未读取到进程信息
    if (empty($content)) {
        return true;
    }

    // 判断是否包含进程名称
    return stripos($content, static::$processTitle) !== false;
}