先看日志丢行。代码用 file_put_contents($log, $line, FILE_APPEND) 追加一行访问记录。单进程测试一切正常,上量之后开始出现「两条日志黏在一行」,偶尔还有整行消失。原因是多个 FPM worker 同时写同一个文件:每个请求都先读文件大小、再定位、再写,两个进程拿到同一个偏移,后写的把先写的覆盖了;或者一次写入被拆成多次系统调用,中间插进了另一个进程的内容。

再看定时任务重叠。脚本每分钟由 cron 拉起,正常几百毫秒跑完。某天数据量涨了十倍,一轮要跑八十秒。cron 不管上一轮结没结束,下一轮照常启动,于是两三个实例同时读同一批数据、同时写同一张汇总表,数字开始翻倍。这两个问题的解法都指向同一件事:多个进程访问同一份共享资源时,必须有一个互斥机制。

这篇先讲 PHP 到底有哪些「进程」,再说 pcntl 能在哪里用,然后重点讲 flock() 的语义和边界,最后落到两个可以直接抄的写法:并发安全追加日志、cron 单实例。

已在本机 Windows 11 + PHP 8.3.36 CLI 实测:extension_loaded('pcntl') 与 function_exists('pcntl_fork') 均为 false,pcntl 相关示例在本机无法执行。flock 示例全部跑过:两个句柄互斥、非 flock 写入被拒绝、10×1000 次并发追加在加锁时 10000 行 0 条格式错误,不加锁时只剩 7917 行且有 162 条错行。

PHP 里到底有几个「进程」

PHP 本身不创建线程,一个请求就是一个执行流,跑在 FPM 的某个 worker 进程里。FPM 的 master 管着一组 worker,每个 worker 同一时间处理一个请求。所以「多个用户同时访问」在系统层面就是「多个 worker 并发执行」,它们之间没有共享的 PHP 变量,也没有共享的堆内存。

请求级内存变量、对象、数组,请求结束就释放。两个 worker 各自一份,改不到对方。
进程级资源打开的文件句柄、数据库连接、APCu 缓存。worker 常驻期间存在,但每个 worker 独立。
跨进程共享文件、数据库、Redis、共享内存。这是多个 worker 唯一能达成共识的地方。

理解这三层,很多「为什么本地好好的」就有答案了。static 变量只在当前请求内有效,下次请求换了个 worker,值就没了;APCu 存在 worker 进程里,同一台机器的不同 worker 各存各的;文件锁能跨同机进程,跨机器就失效。共享状态放在哪一层,决定了并发问题怎么解。

还有一个常被忽略的事实:FPM worker 的数量是固定的,每个 worker 一次只处理一个请求。如果一个请求在等锁、等网络、等磁盘,占着 worker 不放手,其他请求就只能排队。并发问题的后果不只是数据写错,还会把整个进程池拖满,表现为全站变慢。所以锁的持有时间、阻塞调用的超时,都要按「worker 是稀缺资源」来设计。

pcntl:只在 CLI 里可用

pcntl 是 PHP 的进程控制扩展,提供 pcntl_fork()、pcntl_waitpid()、pcntl_signal() 等函数。它有一个硬限制:不能在 Web SAPI 里使用。FPM 环境下调用 pcntl_fork() 会直接报错,很多发行版干脆把整个扩展排除在 FPM 的配置之外。所以在网页请求里想「开个子进程去干活」这条路,默认走不通。

它真正适合的场景是 CLI 脚本:批量导入、数据迁移、常驻消费者。这些脚本本来就在终端或 supervisor 下运行,fork 出来的子进程可以用来并行处理分片。

<?php
$pids = [];
for ($i = 0; $i < 3; $i++) {
    $pid = pcntl_fork();
    if ($pid === -1) {
        throw new RuntimeException('fork 失败');
    }
    if ($pid === 0) {
        // 子进程:必须自己退出,否则会继续执行父进程的后续代码
        echo "child $i pid=" . getmypid() . PHP_EOL;
        exit(0);
    }
    $pids[] = $pid;
}

foreach ($pids as $pid) {
    pcntl_waitpid($pid, $status);
    echo "child $pid exit=" . pcntl_wexitstatus($status) . PHP_EOL;
}

「跑什么、看到什么算通过」:保存为 fork_demo.php,执行 php fork_demo.php,应当看到三行 child 0/1/2 和各自的 pid,再看到三行 exit=0。如果只看到 child 0 不停重复,说明子进程没有 exit,把父进程的循环又跑了一遍。

fork 之后有几个坑必须知道。第一,子进程继承父进程已打开的数据库连接,但连接是父子共享的套接字,两边同时用会串包,标准做法是在子进程里把连接置空并重新连。第二,父进程已经缓冲的输出会被复制,子进程退出时可能重复刷出,命令行脚本里最好在 fork 前 fflush() 或直接避免共享输出。第三,子进程结束必须回收,否则就是僵尸进程,和 POSIX 那套规则一样。

信号处理在 CLI 长驻脚本里很常用。pcntl_signal(SIGTERM, ...) 注册处理函数,配合 pcntl_async_signals(true) 让信号到达时立即执行,或者显式调用 pcntl_signal_dispatch()。收到退出信号时把当前一批处理完再退,比直接被杀掉安全。

CLI 脚本的生命周期管理通常交给 supervisor、systemd 或容器编排,不要自己写守护进程那一套。父进程只负责拉起和回收子进程,真正的任务在子进程里跑;子进程异常退出要有日志和重启策略,否则一个分片失败,整批数据就少一块。fork 出来的子进程数不是越多越好,超过 CPU 核数只会增加上下文切换,数据库连接数也会跟着涨。

flock 锁的是句柄,不是文件名

flock() 是 PHP 里最简单可用的进程间互斥手段。用法是打开一个文件拿到句柄,再对这个句柄加锁。锁有两种:LOCK_EX 排他锁,别人不能加任何锁;LOCK_SH 共享锁,多个读可以同时持有,写要等所有人释放。加 LOCK_NB 表示不等待,拿不到立刻返回 false。

关键点是锁的粒度:flock() 锁的是「打开的文件描述」这个对象,不是路径字符串。同一进程打开同一个文件两次,会得到两个独立的句柄,但本机 Windows 11 + PHP 8.3.36 实测这两个句柄仍然互斥:第一个 LOCK_EX | LOCK_NB 返回 true,第二个立刻返回 false;释放第一个后第二个才能拿到。锁在 fclose() 时释放,进程崩溃退出时也会被内核释放,所以不会像手写 pid 文件那样留下永久残留。

适合 flock 的场景

同一台机器上的多个 PHP 进程互斥:本地日志、单实例定时任务、本地缓存的写回。实现简单,进程死了锁自动放。

不适合 flock 的场景

多台服务器共享一个 NFS 挂载点。NFS 上的 flock 依赖服务端支持,行为和本地文件系统不完全一致,关键业务不要拿它当分布式锁。

还有一条容易误解的规则:flock() 在 Linux 上是建议锁,不调用 flock() 的写入不受约束;但在本机 Windows 11 + PHP 8.3.36 上实测是强制锁:持锁期间另一个进程的 file_put_contents() 直接失败并报 errno=13 Permission denied,file_get_contents() 也读不到。跨平台代码不能假设「不锁也能写」,所有访问同一资源的代码都必须走同一套加锁逻辑。

阻塞加锁没有内置超时。默认的 LOCK_EX 会一直等,持有者卡死,等的人也跟着卡死。需要超时就自己写重试:用 LOCK_EX | LOCK_NB 循环尝试,每次失败 usleep() 一小段,累计超过阈值就放弃。这样既能给用户一个明确的失败,也不会把 worker 永久占住。

并发追加日志的正确写法

回到开头那个日志丢行的问题。修法不是在 file_put_contents() 外面套一层锁,而是打开一个追加模式的句柄,在锁内写完、刷出、再解锁。

<?php
function appendLog(string $file, string $line): void {
    $fp = fopen($file, 'ab');
    if ($fp === false) {
        throw new RuntimeException("无法打开日志文件: $file");
    }
    try {
        if (!flock($fp, LOCK_EX)) {
            throw new RuntimeException('日志加锁失败');
        }
        fwrite($fp, $line . PHP_EOL);
        fflush($fp);          // 把缓冲刷到文件,再解锁
        flock($fp, LOCK_UN);
    } finally {
        fclose($fp);          // 异常路径也要释放句柄和锁
    }
}

「跑什么、看到什么算通过」:写一个脚本 fork 出 10 个子进程,每个往同一个文件追加 1000 行带自己 pid 的记录。跑完统计总行数应当是 10000,且每行都完整。去掉 flock() 再跑一次,大概率会少于 10000,或者出现两段内容挤在一行。

为什么用 ab 而不是 a:b 是二进制模式,避免任何换行转换;追加模式下文件指针总在末尾,不会出现「先读大小再定位」的竞争。fflush() 不能省,PHP 的流有写缓冲,解锁时数据可能还在用户态缓冲里,另一个进程紧接着写入就会打乱顺序。

如果日志量很大,每个请求都开文件、加锁、刷盘,开销会很明显。工程上的替代方案是交给系统日志(syslog、error_log)或专门的日志库,由它做批量写入和轮转。自己写文件适合量小、需要精确控制的场景。

轮转也要按同样的规则来。外部工具把 app.log 改名成 app.log.1 再新建文件时,进程手里还握着旧文件的句柄,会继续往旧文件写,直到重新打开。利用这一点可以实现「按天轮转」,但前提是每个写入方都能定期检查文件是否还在原位;否则就会出现「日志看起来不更新,其实写进了已经改名的文件」。轮转和加锁必须由同一套机制管理,别让两个进程各自决定什么时候换文件。

用文件锁做单实例任务

定时任务重叠的标准解法是「锁文件加非阻塞排他锁」:任务开始时尝试加锁,拿不到就说明已经有一个实例在跑,直接退出。不要用「检查 pid 文件里的进程是否存在」这种写法,pid 会复用,判断不可靠。

<?php
$lockFile = __DIR__ . '/runtime/stats.lock';
$fp = fopen($lockFile, 'c');
if ($fp === false) {
    fwrite(STDERR, "无法打开锁文件\n");
    exit(1);
}

if (!flock($fp, LOCK_EX | LOCK_NB)) {
    fwrite(STDERR, "已有实例在运行,退出\n");
    exit(0);
}

try {
    runStatistics();          // 真正的任务
} finally {
    flock($fp, LOCK_UN);
    fclose($fp);
}

「跑什么、看到什么算通过」:把 runStatistics() 换成 sleep(5),开两个终端几乎同时执行。第一个会等待并结束,第二个应当立刻打印「已有实例在运行」并退出,退出码为 0。等第一个跑完再执行,又能正常拿到锁。

fopen($lockFile, 'c') 的 c 模式表示「打开用于写入,不存在就创建,但不截断」,适合锁文件。锁文件本身不需要内容,存在即可。进程被杀时内核会关闭它的所有句柄,锁随之释放,所以不会出现「上次崩了,锁永远拿不到」的情况。

任务内部也要考虑超时。一个实例卡死不走,锁一直不放,后续任务全部被拒。可以给任务加一个最长执行时间,超时就自己退出;或者在锁文件旁记录开始时间,运维据此发现异常实例。锁只解决「同时跑」,不解决「跑不完」。

锁文件放在哪里也有讲究。放在 /tmp 里,系统重启可能被清掉,问题不大;放在代码目录里,要确认 Web 用户或 CLI 用户有写权限,且不会被部署脚本覆盖。多台机器各自用本地锁文件时,文件名要能区分实例,避免把「两台机器」误当成「两个进程」。

跨机器时,文件锁就不够了

多台 Web 服务器共用一套代码,文件锁各自锁各自的本地文件,完全不起作用。这时互斥必须放在所有机器都能访问的地方:数据库的一行记录、Redis 的一个键、或者专门的任务队列。

共享范围决定锁放在哪
单机多进程flock 锁本地文件,简单可靠
多机共享状态数据库行锁或 Redis 原子命令
任务只跑一次交给队列,由消费者抢占

数据库锁的写法因引擎而异:MySQL 的 SELECT ... FOR UPDATE 要在事务里,锁住的是行;用一张专门的锁表,插入唯一键也能实现互斥。Redis 用 SET key value NX EX seconds,设置成功才算拿到锁,过期时间防止实例崩溃后死锁。注意过期时间要大于任务最长执行时间,否则任务没完锁就没了,另一个实例会进来。

不管用哪种锁,都要回答三个问题:谁能拿到、拿不到怎么办、拿到的人崩了怎么办。文件锁靠内核释放,数据库锁靠事务结束,Redis 锁靠过期时间。三者都不是银弹,选哪个取决于你的共享范围和故障模型。

数据库锁还要注意两个副作用。行锁在事务里持有,事务越长,锁越久,其他请求等得越久;并发一高,死锁检测会主动杀掉其中一个事务,业务代码必须能处理这种失败并重试。不要把「拿锁、发 HTTP 请求、写日志」塞进同一个事务,网络一慢,锁就跟着卡住整张表。

现象、真实原因、第一步查什么

你看到的现象真实原因第一步查什么
日志偶尔少行或两行黏在一起多个进程同时写,偏移竞争或写入被拆开看写入代码有没有 flock(),以及是否用了追加模式
定时任务的数据翻倍或互相覆盖上一轮没结束,下一轮已经启动确认是否有非阻塞锁;看进程列表里是否同时存在多个实例
加了锁,另一个脚本照样写进去flock 是建议锁,对方没调用 flock检查所有写入方是否都走同一套加锁路径
同一进程里两个句柄锁不住锁属于打开的文件描述,不同句柄各自独立确认加锁和解锁用的是同一个 $fp
NFS 上锁偶尔失效网络文件系统的锁语义依赖服务端实现换成本地文件或数据库锁做对照测试
fork 后子进程重复执行父进程逻辑子进程分支里没有 exit在每个 $pid === 0 分支末尾确认有退出
fork 后数据库报连接错误父子共享同一个连接套接字子进程里重新建立连接,别复用父进程的
锁文件一直在,任务却拿不到锁文件存在不等于锁存在,锁随进程释放看是锁被占用,还是代码把「文件存在」当成了「锁存在」

边界与代价

  • 锁会降低并发。把整段任务包进一把大锁,等于让所有请求排队。锁的范围要尽量小,只包住真正的共享写。
  • 加锁顺序不一致会死锁。两个进程各拿一把锁再等对方,谁都走不了。约定全局的加锁顺序,或者用带超时的尝试锁。
  • 文件锁只解决同机互斥。跨机器要靠数据库或 Redis,跨数据中心还要考虑网络分区。
  • pcntl 不能用于 Web 请求。想在网页里并行,应该用队列或异步方案,而不是 fork。
  • 锁不是事务。它只保证同一时刻只有一个人在写,不保证写成功、不保证写到磁盘、更不保证业务逻辑正确。
  • 排查并发问题要先确认「是不是真的并发」。有时候日志丢行是磁盘满、轮转竞争或权限问题,不是锁的问题;先看文件是否完整、进程是否重叠,再决定加不加锁。

当天能自己验证的练习

  • 写一个并发追加日志脚本,用 pcntl_fork() 起 10 个子进程各写 1000 行,分别在有锁和无锁的情况下统计最终行数。
  • 把单实例任务的 runStatistics() 换成 sleep(5),同时启动两个实例,验证第二个是否立刻退出。
  • 写一个用文件锁保护的计数器,10 个进程各加 1000 次,最后读出的值应当是 10000;去掉锁再跑,记录丢失的数量。
  • 在同一个进程里打开同一个文件两次,各加 LOCK_EX | LOCK_NB,观察第二次是否能成功,理解「锁属于句柄」。
  • 用数据库唯一键或 Redis 的 SET NX EX 实现一个跨进程互斥,和文件锁版本对比,记录两者在多机场景下的差别。

小结

三句话:PHP 的并发来自多个 worker 进程,变量不共享,共享只能靠文件、数据库或缓存;flock() 是建议锁,锁的是打开的文件描述,只在同机有效;并发写文件要用追加模式加锁并在解锁前刷出,定时任务用非阻塞排他锁保证单实例。

进程之间能互斥了,下一个问题是「等待」:一个请求要调三个接口,串行太慢;用了 Fiber 却发现还是串行。下一篇讲 PHP 的异步,把 Fiber、事件循环和没有扩展时的替代方案讲清楚。