Self-Pipe Trick:把信号和线程唤醒接入事件循环
1 前言
事件循环的阻塞点通常是一个poll、select或epoll_wait。网络fd可读可写时这些调用返回,进程还要处理另一类事件:信号、其他线程投递的任务、定时器。把信号直接接进事件循环,常见写法是在handler里置一个volatile sig_atomic_t标志(sig_atomic_t保证写入在信号处理过程中不可分割,volatile禁止编译器把它缓存进寄存器),主循环检查标志后再进入poll。这个写法有两个独立的问题。
handler的运行环境不受控:它可能打断malloc持锁的瞬间,handler里再调用printf或malloc会去拿同一把锁,进程死锁。另一个问题是检查与等待之间的窗口:标志在检查之后、poll之前被置位,poll仍会睡下去。EINTR只能处理“信号在等待期间到达”的情况,补不上这个窗口。
self-pipe把两个问题一起消掉:handler只向管道写一个整数,主循环把管道读端加入poll集合。信号被转换成fd可读,异步通知进入同步的I/O事件流。这套机制同时适用于信号和跨线程唤醒,PostgreSQL的latch和不少网络库的事件循环都在用。
2 async-signal-safe
信号handler可以随时打断主流程。考虑main正在malloc内部持有堆锁,信号到达,handler为了记录日志调用printf,printf内部也要拿锁,锁已经被主流程持有,handler永远等不到,进程死锁。free、fopen、syslog有同样的问题。POSIX把这些函数排除在async-signal-safe列表之外,只保证write、read、close、_exit、sigaction、kill等少数函数可以在handler中调用。
1
2
3
4
5
6
7
// bad_handler.cpp
static volatile sig_atomic_t g_stop = 0;
void on_signal(int signo) {
printf("signal %d\n", signo); // printf 不是 async-signal-safe
g_stop = 1;
}
errno是另一个容易漏掉的点。handler可能改写errno,返回主流程后原来的错误码已经丢失,后续的perror或错误分支会读到错误值。下面的handle_signal出自第5节的SignalPipe——所有信号共用这一个handler,把信号编号写进同一个管道写端,管道创建和安装接口在第5节交代。开头保存、结尾恢复errno:
1
2
3
4
5
6
7
8
9
10
11
// signal_pipe.cpp
void SignalPipe::handle_signal(int signo, siginfo_t*, void*) {
int saved_errno = errno;
int value = signo;
ssize_t written;
do {
written = ::write(write_fd_, &value, sizeof(value));
} while (written == -1 && errno == EINTR);
(void)written;
errno = saved_errno;
}
sigaction的SA_RESTART标志让被信号打断的系统调用自动重启,但Linux上poll、select、epoll_wait不在重启之列:无论是否设置SA_RESTART,信号到达都返回EINTR。依赖SA_RESTART处理唤醒,等于把行为交给平台细节。代码里仍然要对EINTR做重试,同时不能把重试当成完整的解决方案。
3 竞态
只置标志的写法有一个更隐蔽的问题:检查标志和进入等待不是原子的。
1
2
3
4
5
6
7
8
9
10
// flag_only.cpp
static volatile sig_atomic_t g_stop = 0;
void on_term(int) {
g_stop = 1;
}
while (!g_stop) {
poll(fds, nfds, -1); // 信号可能在上一次检查之后、进入这里之前到达
}
时间线里信号在检查之后、poll之前到达。handler已经置位,poll却只关心fd,没有理由返回。若信号在poll睡眠期间到达,poll会被打断并返回EINTR,主循环重试后能看到标志;丢失只发生在进入等待之前的那个窗口。
pselect、ppoll、epoll_pwait在进入等待的调用里原子替换信号掩码——先阻塞、等待时解除——信号只能落在“已经准备好等待”之后。self-pipe走另一条路,不改变信号掩码,而是让通知在管道里排队,poll无论如何都能看到它。
4 self-pipe的工作方式
pipe()创建一对fd,读端加入事件循环的监听集合,写端只在handler里使用。handler写入一个int,内容是信号编号。管道的缓冲区把这次写入保存下来,即使信号在poll之前到达,读端也已经可读,poll会立即返回。
图上两条写入路径对应两种用法。数据型把信号编号写进管道,主循环读出后按编号调用回调;唤醒型只写一个dummy字节,真实状态放在flag或队列里,管道只负责把线程从poll里叫醒。数据型适合信号到回调的一一映射,唤醒型适合latch、跨线程消息队列这类“状态在别处”的场景。
两种用法都依赖同一个前提:写端必须是非阻塞的。管道满时write返回EAGAIN,说明里面已经有未处理的唤醒。唤醒型可以安全丢弃,因为“有唤醒待处理”这个信息已经足够;数据型丢掉的是具体的信号编号——管道满的瞬间SIGINT到达、写入失败,稍后到达的SIGUSR1却正常入管,进程就在不知情中错过了一次终止请求。需要严格计数的场景应改用signalfd或实时信号,self-pipe的定位是唤醒而不是可靠队列。写端如果是阻塞的,handler会卡在write里,整个进程停住。
5 C++实现
SignalPipe把所有状态收进一个对象:pipe fd、信号处理表、安装标记。init只做一次,创建管道并设置O_CLOEXEC | O_NONBLOCK;set_handler安装统一的sigaction;dispatch在主循环上下文里读取并分发。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// signal_pipe.cpp
bool SignalPipe::init(std::string* error) {
if (read_fd_ != -1 || instance_ != nullptr) {
if (error) *error = "already initialized";
return false;
}
int fds[2];
if (::pipe2(fds, O_CLOEXEC | O_NONBLOCK) == -1) {
if (error) *error = errno_message("pipe2");
return false;
}
read_fd_ = fds[0];
write_fd_ = fds[1];
instance_ = this;
return true;
}
pipe2是Linux接口,其他UNIX用pipe加两次fcntl完成同样的事。两个fd都设O_NONBLOCK,读端为了dispatch能读到EAGAIN为止,写端为了handler不阻塞。O_CLOEXEC防止fd泄漏给exec的子进程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// signal_pipe.cpp
bool SignalPipe::set_handler(int signo, Handler handler) {
if (signo <= 0 || signo >= kMaxSignal) return false;
handlers_[signo] = std::move(handler);
struct sigaction sa;
std::memset(&sa, 0, sizeof(sa));
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = &SignalPipe::handle_signal;
sa.sa_flags = SA_SIGINFO | SA_RESTART;
if (::sigaction(signo, &sa, nullptr) == -1) {
handlers_[signo] = nullptr;
return false;
}
installed_[signo] = true;
return true;
}
dispatch先把管道里已有的整数全部读进pending,再逐个调用handler。这个顺序是关键:如果读一个、处理一个,再“清空并丢弃”剩余数据,处理期间新到达的信号会被丢掉。先排空、后分发,处理期间到达的信号留在管道里,下一轮poll会再次唤醒。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// signal_pipe.cpp
int SignalPipe::dispatch() {
std::vector<int> pending;
pending.reserve(64);
for (;;) {
int buf[64];
ssize_t n = ::read(read_fd_, buf, sizeof(buf));
if (n > 0) {
const std::size_t count = static_cast<std::size_t>(n) / sizeof(int);
for (std::size_t i = 0; i < count; ++i) pending.push_back(buf[i]);
if (static_cast<std::size_t>(n) < sizeof(buf)) break;
continue;
}
if (n == -1 && errno == EINTR) continue;
break; // EAGAIN:管道已空
}
int dispatched = 0;
for (int signo : pending) {
if (signo > 0 && signo < kMaxSignal && handlers_[signo]) {
handlers_[signo](signo);
++dispatched;
}
}
return dispatched;
}
管道写入不大于PIPE_BUF时是原子的,一个int不会和其他写入交错。所有写入方都按sizeof(int)写,读缓冲区也按sizeof(int)对齐,读出来的字节数始终是int的整数倍。
主循环侧把读端当成一个普通fd加进poll集合即可:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// main.cpp(骨架)
SignalPipe signals;
signals.init(&error);
signals.set_handler(SIGINT, [](int) { g_running = false; });
signals.set_handler(SIGTERM, [](int) { g_running = false; });
struct pollfd fds[2] = {
{listen_fd, POLLIN, 0}, // 任一业务fd
{signals.read_fd(), POLLIN, 0},
};
while (g_running) {
int n = ::poll(fds, 2, -1);
if (n == -1) {
if (errno == EINTR) continue; // 字节已在管道里,重试不丢唤醒
break;
}
if (fds[1].revents & POLLIN)
signals.dispatch(); // 排空管道、在主循环上下文调用handler
}
信号到达时handler写入管道,poll以POLLIN返回,dispatch排空管道并调用handler,handler在主循环上下文里修改g_running,循环在下一轮判断处退出。EINTR分支直接重试即可,唤醒字节已经在管道里等着。
| 细节 | 原因 | 处理 |
|---|---|---|
| 写端非阻塞 | handler不能阻塞 | pipe2(... O_NONBLOCK),EAGAIN视为已有唤醒 |
write重试EINTR | handler可能被其他信号打断 | do/while重试,保存并恢复errno |
| 先drain后dispatch | 避免丢弃处理期间到达的信号 | 读到EAGAIN再调用handler |
| 读端非阻塞 | 收尾的read不能挂住 | O_NONBLOCK,EAGAIN结束循环 |
CLOEXEC | 防止fd泄漏给子进程 | pipe2的O_CLOEXEC |
SIGPIPE | 读端关闭后写入触发SIGPIPE | 保持读端打开,或忽略SIGPIPE |
| fork | 子进程继承fd | 子进程关闭不需要的副本 |
| 多线程 | 进程信号可能投递到任意线程 | 需要固定线程时用pthread_sigmask屏蔽其他线程 |
多线程下,进程级信号会投递给任意一个没有屏蔽它的线程。handler写的是同一个管道,所以唤醒可能落在任意线程的poll上。如果事件循环只在一个线程里运行,其他线程应在创建前用pthread_sigmask屏蔽这些信号,避免信号被无关线程接走。signalfd把屏蔽做成硬性要求——信号不阻塞就走默认处置,fd上永远读不到——self-pipe没有这个限制,但线程分工仍然要自己保证。
SIGPIPE只在读端已经关闭时出现。正常生命周期里读端一直打开,析构时先恢复handler,再关闭写端和读端,就不会触发。若业务代码可能提前关闭读端,启动时用signal(SIGPIPE, SIG_IGN)或类的set_ignore(SIGPIPE)兜底。
6 跨线程唤醒
事件循环不只等信号,还要被其他线程叫醒。线程B把任务放进队列后,写一个字节到同一个管道;线程A从poll返回,先排空管道,再在同一把锁里交换队列并清掉通知标志。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// wakeup_queue.hpp
void post(int value) {
bool need_write = false;
{
std::lock_guard<std::mutex> lock(mutex_);
queue_.push_back(value);
if (!notified_) {
notified_ = true;
need_write = true;
}
}
if (need_write) {
char byte = 1;
ssize_t written;
do {
written = ::write(write_fd_, &byte, 1);
} while (written == -1 && errno == EINTR);
}
}
std::vector<int> take() {
char buf[256];
for (;;) {
ssize_t n = ::read(read_fd_, buf, sizeof(buf));
if (n > 0) continue;
if (n == -1 && errno == EINTR) continue;
break;
}
std::lock_guard<std::mutex> lock(mutex_);
std::vector<int> batch;
batch.swap(queue_);
notified_ = false;
return batch;
}
take的drain在锁外,交换队列和清notified_在锁内。从生产者视角看:锁内入队并检查notified_,标志为真说明已经有一个唤醒在管道里,不写字节,消费者随后会在同一次take里把新消息一起换走;标志为假则写字节,下一轮poll立即返回。约束是“交换队列”和“清标志”必须落在同一个临界区:若二者分开,就会出现“队列里有消息、管道里没有字节、也没有人再写”的状态,唤醒就此丢失。
多个通知可以合并成一个字节,唤醒次数远小于消息数。唤醒次数按poll因管道可读而返回的次数计,一次测试里线程B连续投递5000条消息,线程A只被唤醒101次,消息一条不少。skywind的poll封装用pipe_written标志做同样的合并,并在每次醒来后调用poller_pipe_reset。
Windows的select只接受socket,不接受管道,跨平台库通常用socketpair或两个已连接的socket代替。Linux的eventfd更直接:内核维护一个64位计数器,write累加,read取走并清零,EFD_SEMAPHORE让每次read只减一。它没有两个fd,也不会产生SIGPIPE,适合纯计数唤醒;局限是只有Linux支持,而且不能像self-pipe那样顺带承载信号编号。
7 替代方案对比
pselect、ppoll、epoll_pwait在等待调用里多一个sigmask参数,进入睡眠时原子地替换进程信号掩码,返回时恢复。调用方在检查标志前先阻塞信号,检查完再交给等待函数解除阻塞,信号只能落在已经开始等待之后。pselect的timeout是timespec,精度到纳秒;ppoll和epoll_pwait是Linux扩展。
表中“信号需阻塞”指该机制要求相关信号处于blocked状态才有意义:pselect一族靠阻塞保证信号只能落在等待期间、由handler先行处理,signalfd靠阻塞让信号以可读数据进fd。self-pipe不要求阻塞,因为handler仍然通过sigaction安装。
| 机制 | 平台 | 携带数据 | 信号需阻塞 | 备注 |
|---|---|---|---|---|
| self-pipe | POSIX | 信号编号或自定义数据 | 否 | 可用于任意I/O多路复用器 |
pselect | POSIX | 否,靠标志 | 是 | timespec超时 |
ppoll | Linux | 否,靠标志 | 是 | poll加sigmask |
epoll_pwait | Linux | 否,靠标志 | 是 | epoll加sigmask |
signalfd | Linux 2.6.22+ | signalfd_siginfo | 是 | 标准信号仍会合并 |
eventfd | Linux 2.6.22+ | 64位计数器 | 否 | 只做唤醒,不承载信号 |
timerfd | Linux 2.6.22+ | 到期次数 | 否 | 定时器转fd |
signalfd把信号变成可读fd,读取的是signalfd_siginfo,带si_pid、si_code等字段,比self-pipe的int信息更全。代价是必须阻塞信号,否则默认动作会先执行;多线程程序要在所有线程里屏蔽,才能保证由目标线程读取。标准信号在signalfd里同样会合并,不会变成可靠队列。
eventfd和timerfd解决的是另外两类事件,不替代信号处理。eventfd适合跨线程唤醒和计数,timerfd适合把定时器接入poll。self-pipe的价值在于它是这些机制里唯一同时满足“POSIX可移植、可接任意多路复用器、不需要阻塞信号、可承载少量数据”的方案。
pselect在Linux 2.6.16之前由glibc用sigprocmask加select模拟,模拟版本仍然存在它本应消除的竞态;现代glibc在有系统调用时使用无竞态的实现。老内核上的可移植性因此要多看一眼。
8 PostgreSQL latch
PostgreSQL的latch.c把self-pipe用在进程内的等待唤醒上。文件头注释直接点出动机:信号本身在部分平台上不会打断poll,即使在会打断的平台上,信号在poll调用之前到达也不会阻止它进入睡眠;管道里的字节则能可靠地让poll立即返回。注释里的原话是“a signal that arrives just before the poll() call does not prevent poll() from entering sleep”,管道字节解决的就是这个窗口。
1
2
3
4
5
6
7
8
9
10
11
// latch.c
if (pipe(pipefd) < 0)
elog(FATAL, "pipe() failed: %m");
if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1)
elog(FATAL, "fcntl(F_SETFL) failed on read-end of self-pipe: %m");
if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1)
elog(FATAL, "fcntl(F_SETFL) failed on write-end of self-pipe: %m");
if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1)
elog(FATAL, "fcntl(F_SETFD) failed on read-end of self-pipe: %m");
if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1)
elog(FATAL, "fcntl(F_SETFD) failed on write-end of self-pipe: %m");
写端和读端都设非阻塞,两个fd都设FD_CLOEXEC。唤醒信号选的是SIGURG,handler只在进程处于等待状态时写一个字节;等待与否由waiting标志记录,进入WaitLatch时置位、返回前清零。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// latch.c
static void latch_sigurg_handler(SIGNAL_ARGS) {
if (waiting)
sendSelfPipeByte();
}
static void sendSelfPipeByte(void) {
int rc;
char dummy = 0;
retry:
rc = write(selfpipe_writefd, &dummy, 1);
if (rc < 0) {
if (errno == EINTR)
goto retry;
if (errno == EAGAIN || errno == EWOULDBLOCK)
return; // 管道里已有字节,足够唤醒
return;
}
}
这里写的是dummy字节,不是信号编号。latch的真实状态在is_set标志和等待状态机里,管道只负责把poll叫醒——第4节的唤醒型正是这个分工;醒来后代码检查latch状态,而不是从管道里解析事件。这个选择让多次SetLatch自然合并成一次唤醒,EAGAIN也可以安全忽略。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// latch.c
static void drain(void) {
char buf[1024];
int fd = selfpipe_readfd;
for (;;) {
int rc = read(fd, buf, sizeof(buf));
if (rc < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK)
break; // 管道已空
else if (errno == EINTR)
continue; // 被信号打断
else
elog(ERROR, "read() on self-pipe failed: %m");
} else if (rc == 0) {
elog(ERROR, "unexpected EOF on self-pipe");
} else if (rc < sizeof(buf)) {
break; // 短读:原注释据此视为已排空
}
}
}
drain在错误和EOF分支都会把waiting清零,这段省略了该状态处理。短读分支沿用原注释的判断——”we successfully drained the pipe; no need to read() again”;即使读之后又有新信号写入,残留数据让fd保持可读,下一轮poll照样立即返回。
latch.c按平台选择等待原语。poll路径用self-pipe;epoll路径把SIGURG阻塞后用signalfd,fd直接进epoll;kqueue路径用EVFILT_SIGNAL监听SIGURG;Windows路径用可继承的event对象。四种实现的共同目标相同:把“有人设置了latch”变成等待原语能识别的可读事件,且不留下检查与等待之间的窗口。self-pipe是其中可移植性最好、依赖最少的一种。
SetLatch在检查is_set前和置位后各放一次内存屏障;等待侧先置maybe_sleeping,再用内存屏障并重新检查is_set。管道字节和这两个标志配合,覆盖“信号在检查前到达”“信号在检查后、睡眠前到达”“信号在睡眠中到达”三种情况。细节在WaitEventSetWait和SetLatch里,self-pipe只是其中的唤醒通道。
references
- [C语言] 安全的信号处理:Self-Pipe技巧 — https://nimfsoft.art/zh/blog/2025/07/23/c-safe-signal-handling-self-pipe/
- PostgreSQL随手记(6)latch实现中self-pipe trick解决什么问题 — https://cloud.tencent.com/developer/article/2048174
- 异步事件模型的Self-pipe trick — https://skywind.me/blog/archives/3163
- Self-Pipe Trick, pselect() and ppoll() Explained — https://embeddedpathashala.com/self-pipe-trick-pselect-and-ppoll-explained/
- POSIX signal safety — https://man7.org/linux/man-pages/man7/signal-safety.7.html
- pselect(2) — https://man7.org/linux/man-pages/man2/pselect.2.html
- signalfd(2) — https://man7.org/linux/man-pages/man2/signalfd.2.html
- eventfd(2) — https://man7.org/linux/man-pages/man2/eventfd.2.html
- timerfd_create(2) — https://man7.org/linux/man-pages/man2/timerfd_create.2.html
- PostgreSQL latch.c — https://github.com/postgres/postgres/blob/REL_17_STABLE/src/backend/storage/ipc/latch.c
- The self-pipe trick — https://cr.yp.to/docs/selfpipe.html