Linux 多线程应用中编写安全的信号处理函数

时间 2019-11-12

原文原文链接

在开发多线程应用时，开发人员通常都会考虑线程安全，会使用 pthread_mutex 去保护全局变量。若是应用中使用了信号，并且信号的产生不是由于程序运行出错，而是程序逻辑须要，譬如 SIGUSR一、SIGRTMIN 等，信号在被处理后应用程序还将正常运行。在编写这类信号处理函数时，应用层面的开发人员却每每忽略了信号处理函数执行的上下文背景，没有考虑编写安全的信号处理函数的一些规则。本文首先介绍编写信号处理函数时须要考虑的一些规则；而后举例说明在多线程应用中如何构建模型让由于程序逻辑须要而产生的异步信号在指定的线程中以同步的方式处理。html

回页首linux

线程和信号编程

Linux 多线程应用中，每一个线程能够经过调用 pthread_sigmask() 设置本线程的信号掩码。通常状况下，被阻塞的信号将不能中断此线程的执行，除非此信号的产生是由于程序运行出错如 SIGSEGV；另外不能被忽略处理的信号 SIGKILL 和 SIGSTOP 也没法被阻塞。安全

当一个线程调用 pthread_create() 建立新的线程时，此线程的信号掩码会被新建立的线程继承。多线程

POSIX.1 标准定义了一系列线程函数的接口，即 POSIX threads(Pthreads)。Linux C 库提供了两种关于线程的实现：LinuxThreads 和 NPTL(Native POSIX Threads Library)。LinuxThreads 已通过时，一些函数的实现不遵循POSIX.1 规范。NPTL 依赖 Linux 2.6 内核，更加遵循 POSIX..1 规范，但也不是彻底遵循。异步

基于 NPTL 的线程库，多线程应用中的每一个线程有本身独特的线程 ID，并共享同一个进程ID。应用程序能够经过调用kill(getpid(),signo) 将信号发送到进程，若是进程中当前正在执行的线程没有阻碍此信号，则会被中断，线号处理函数会在此线程的上下文背景中执行。应用程序也能够经过调用 pthread_kill(pthread_t thread, int sig) 将信号发送给指定的线程，则线号处理函数会在此指定线程的上下文背景中执行。socket

基于 LinuxThreads 的线程库，多线程应用中的每一个线程拥有本身独特的进程 ID，getpid（）在不一样的线程中调用会返回不一样的值，因此没法经过调用 kill(getpid(),signo) 将信号发送到整个进程。ide

下文介绍的在指定的线程中以同步的方式处理异步信号是基于使用了 NPTL 的 Linux C 库。请参考“Linux 线程模型的比较：LinuxThreads 和 NPTL”和“pthreads(7) - Linux man page”进一步了解 Linux 的线程模型，以及不一样版本的 Linux C 库对 NPTL 的支持。函数

回页首测试

编写安全的异步信号处理函数

信号的产生能够是：

用户从控制终端终止程序运行，如 Ctrk + C 产生 SIGINT；

程序运行出错时由硬件产生信号，如访问非法地址产生 SIGSEGV；
程序运行逻辑须要，如调用 kill、raise 产生信号。

因为信号是异步事件，即信号处理函数执行的上下文背景是不肯定的，譬如一个线程在调用某个库函数时可能会被信号中断，库函数提早出错返回，转而去执行信号处理函数。对于上述第三种信号的产生，信号在产生、处理后，应用程序不会终止，仍是会继续正常运行，在编写此类信号处理函数时尤为须要当心，以避免破坏应用程序的正常运行。关于编写安全的信号处理函数主要有如下一些规则：

信号处理函数尽可能只执行简单的操做，譬如只是设置一个外部变量，其它复杂的操做留在信号处理函数以外执行；
errno 是线程安全，即每一个线程有本身的 errno，但不是异步信号安全。若是信号处理函数比较复杂，且调用了可能会改变errno 值的库函数，必须考虑在信号处理函数开始时保存、结束的时候恢复被中断线程的 errno 值；

信号处理函数只能调用能够重入的 C 库函数；譬如不能调用 malloc（），free（）以及标准 I/O 库函数等；
信号处理函数若是须要访问全局变量，在定义此全局变量时须将其声明为 volatile，以免编译器不恰当的优化。

从整个 Linux 应用的角度出发，由于应用中使用了异步信号，程序中一些库函数在调用时可能被异步信号中断，此时必须根据errno 的值考虑这些库函数调用被信号中断后的出错恢复处理，譬如socket 编程中的读操做：

点击(此处)折叠或打开

rlen = recv(sock_fd, buf, len, MSG_WAITALL);
if ((rlen == -1) && (errno == EINTR)){
// this kind of error is recoverable, we can set the offset change
//‘rlen’ as 0 and continue to recv
}

回页首

在指定的线程中以同步的方式处理异步信号

如上文所述，不只编写安全的异步信号处理函数自己有不少的规则束缚；应用中其它地方在调用可被信号中断的库函数时还需考虑被中断后的出错恢复处理。这让程序的编写变得复杂，幸运的是，POSIX.1 规范定义了sigwait()、 sigwaitinfo() 和pthread_sigmask() 等接口，能够实现：

以同步的方式处理异步信号；

在指定的线程中处理信号。

这种在指定的线程中以同步方式处理信号的模型能够避免由于处理异步信号而给程序运行带来的不肯定性和潜在危险。

sigwait

sigwait() 提供了一种等待信号的到来，以串行的方式从信号队列中取出信号进行处理的机制。sigwait（）只等待函数参数中指定的信号集，即若是新产生的信号不在指定的信号集内，则 sigwait（）继续等待。对于一个稳定可靠的程序，咱们通常会有一些疑问：

多个相同的信号可不能够在信号队列中排队？

若是信号队列中有多个信号在等待，在信号处理时有没有优先级规则？
实时信号和非实时信号在处理时有没有什么区别？

笔者写了一小段测试程序来测试 sigwait 在信号处理时的一些规则。

清单 1. sigwait_test.c

点击(此处)折叠或打开

#include <signal.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void sig_handler(int signum)
{
printf("Receive signal. %d\n", signum);
}
void* sigmgr_thread()
{
sigset_t waitset, oset;
int sig;
int rc;
pthread_t ppid = pthread_self();
pthread_detach(ppid);
sigemptyset(&waitset);
sigaddset(&waitset, SIGRTMIN);
sigaddset(&waitset, SIGRTMIN+2);
sigaddset(&waitset, SIGRTMAX);
sigaddset(&waitset, SIGUSR1);
sigaddset(&waitset, SIGUSR2);
while (1) {
rc = sigwait(&waitset, &sig);
if (rc != -1) {
sig_handler(sig);
} else {
printf("sigwaitinfo() returned err: %d; %s\n", errno, strerror(errno));
}
}
}
int main()
{
sigset_t bset, oset;
int i;
pid_t pid = getpid();
pthread_t ppid;
sigemptyset(&bset);
sigaddset(&bset, SIGRTMIN);
sigaddset(&bset, SIGRTMIN+2);
sigaddset(&bset, SIGRTMAX);
sigaddset(&bset, SIGUSR1);
sigaddset(&bset, SIGUSR2);
if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
printf("!! Set pthread mask failed\n");
kill(pid, SIGRTMAX);
kill(pid, SIGRTMAX);
kill(pid, SIGRTMIN+2);
kill(pid, SIGRTMIN);
kill(pid, SIGRTMIN+2);
kill(pid, SIGRTMIN);
kill(pid, SIGUSR2);
kill(pid, SIGUSR2);
kill(pid, SIGUSR1);
kill(pid, SIGUSR1);
// Create the dedicated thread sigmgr_thread() which will handle signals synchronously
pthread_create(&ppid, NULL, sigmgr_thread, NULL);
sleep(10);
exit (0);
}

程序编译运行在 RHEL4 的结果以下：

图 1. sigwait 测试程序执行结果

从以上测试程序发现如下规则：

对于非实时信号，相同信号不能在信号队列中排队；对于实时信号，相同信号能够在信号队列中排队。

如果信号队列中有多个实时以及非实时信号排队，实时信号并不会先于非实时信号被取出，信号数字小的会先被取出：如 SIGUSR1（10）会先于 SIGUSR2 (12)，SIGRTMIN（34）会先于 SIGRTMAX (64)，非实时信号由于其信号数字小而先于实时信号被取出。

sigwaitinfo（）以及 sigtimedwait() 也提供了与 sigwait（）函数类似的功能。

Linux 多线程应用中的信号处理模型

在基于 Linux 的多线程应用中，对于由于程序逻辑须要而产生的信号，可考虑调用 sigwait（）使用同步模型进行处理。其程序流程以下：

主线程设置信号掩码，阻碍但愿同步处理的信号；主线程的信号掩码会被其建立的线程继承；
主线程建立信号处理线程；信号处理线程将但愿同步处理的信号集设为 sigwait（）的第一个参数。
主线程建立工做线程。

图 2. 在指定的线程中以同步方式处理异步信号的模型

代码示例

如下为一个完整的在指定的线程中以同步的方式处理异步信号的程序。

主线程设置信号掩码阻碍 SIGUSR1 和 SIGRTMIN 两个信号，而后建立信号处理线程sigmgr_thread（）和五个工做线程worker_thread（）。主线程每隔10秒调用 kill() 对本进程发送 SIGUSR1 和 SIGTRMIN 信号。信号处理线程 sigmgr_thread（）在接收到信号时会调用信号处理函数 sig_handler()。

程序编译：gcc -o signal_sync signal_sync.c -lpthread

程序执行：./signal_sync

从程序执行输出结果能够看到主线程发出的全部信号都被指定的信号处理线程接收到，并以同步的方式处理。

清单 2. signal_sync.c

点击(此处)折叠或打开

#include <signal.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void sig_handler(int signum)
{
static int j = 0;
static int k = 0;
pthread_t sig_ppid = pthread_self();
// used to show which thread the signal is handled in.
if (signum == SIGUSR1) {
printf("thread %d, receive SIGUSR1 No. %d\n", sig_ppid, j);
j++;
//SIGRTMIN should not be considered constants from userland,
//there is compile error when use switch case
} else if (signum == SIGRTMIN) {
printf("thread %d, receive SIGRTMIN No. %d\n", sig_ppid, k);
k++;
}
}
void* worker_thread()
{
pthread_t ppid = pthread_self();
pthread_detach(ppid);
while (1) {
printf("I'm thread %d, I'm alive\n", ppid);
sleep(10);
}
}
void* sigmgr_thread()
{
sigset_t waitset, oset;
siginfo_t info;
int rc;
pthread_t ppid = pthread_self();
pthread_detach(ppid);
sigemptyset(&waitset);
sigaddset(&waitset, SIGRTMIN);
sigaddset(&waitset, SIGUSR1);
while (1) {
rc = sigwaitinfo(&waitset, &info);
if (rc != -1) {
printf("sigwaitinfo() fetch the signal - %d\n", rc);
sig_handler(info.si_signo);
} else {
printf("sigwaitinfo() returned err: %d; %s\n", errno, strerror(errno));
}
}
}
int main()
{
sigset_t bset, oset;
int i;
pid_t pid = getpid();
pthread_t ppid;
// Block SIGRTMIN and SIGUSR1 which will be handled in
//dedicated thread sigmgr_thread()
// Newly created threads will inherit the pthread mask from its creator
sigemptyset(&bset);
sigaddset(&bset, SIGRTMIN);
sigaddset(&bset, SIGUSR1);
if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
printf("!! Set pthread mask failed\n");
// Create the dedicated thread sigmgr_thread() which will handle
// SIGUSR1 and SIGRTMIN synchronously
pthread_create(&ppid, NULL, sigmgr_thread, NULL);
// Create 5 worker threads, which will inherit the thread mask of
// the creator main thread
for (i = 0; i < 5; i++) {
pthread_create(&ppid, NULL, worker_thread, NULL);
}
// send out 50 SIGUSR1 and SIGRTMIN signals
for (i = 0; i < 50; i++) {
kill(pid, SIGUSR1);
printf("main thread, send SIGUSR1 No. %d\n", i);
kill(pid, SIGRTMIN);
printf("main thread, send SIGRTMIN No. %d\n", i);
sleep(10);
}
exit (0);
}

注意事项

在基于 Linux 的多线程应用中，对于由于程序逻辑须要而产生的信号，可考虑使用同步模型进行处理；而对会致使程序运行终止的信号如 SIGSEGV 等，必须按照传统的异步方式使用 signal（）、 sigaction（）注册信号处理函数进行处理。这两种信号处理模型可根据所处理的信号的不一样同时存在一个 Linux 应用中：

不要在线程的信号掩码中阻塞不能被忽略处理的两个信号 SIGSTOP 和 SIGKILL。
不要在线程的信号掩码中阻塞 SIGFPE、SIGILL、SIGSEGV、SIGBUS。
确保 sigwait() 等待的信号集已经被进程中全部的线程阻塞。
在主线程或其它工做线程产生信号时，必须调用 kill() 将信号发给整个进程，而不能使用 pthread_kill() 发送某个特定的工做线程，不然信号处理线程没法接收到此信号。
由于 sigwait（）使用了串行的方式处理信号的到来，为避免信号的处理存在滞后，或是非实时信号被丢失的状况，处理每一个信号的代码应尽可能简洁、快速，避免调用会产生阻塞的库函数。