鉴于网上超多关于Linux信号处理相关的文章，本篇关于基本的信号知识不再普及，只提出一些平时不常关注或者关注不到的一些方面：
1. 信号可靠性：此可靠指的是信号是否会排队，并不是指信号会丢失（其实在也可以理解为不排队的信号就会丢失）。SIGRTMIN以下的信号不会被排队处理，即只传递一次，如果进程已经有信号还未被处理，后面再来同样的信号即丢失，其他的不同信号还是进入排队处理。SIGRTMIN以上的信号，都会进入队列
2. 信号异步处理：进程注册的信号处理函数将在进程内核态返回用户态时被调用，相对于进程主线程或其他线程来说，是并行处理的
3. 信号同步处理：进程可以选择以同步的方式来处理信号，比如由一个特定的线程来处理
4. 多线程中的信号：对于内核来说，没有进程与线程的区分，所有都是进程；对于进程来说，所有线程共享进程地址空间，包括注册的信号，即子线程会继承主线程所注册的信号环境
5. 谁来执行信号处理函数：异步处理时由最小号的线程来处理；同步处理时由用户特定的调用同步函数的线程来执行
6. 谁可以注册信号：谁都可以注册，主线程子线程都可以；注册与处理不是相关联的
7. 在多个地方注册信号了处理函数，将怎么处理：信号处理函数将以最后调用的信号注册函数为准
关于信号API：
异步处理 sigaction：
void sig_handler(int signum)
{
...
}
struct sigaction action;
memset(&action, 0, sizeof(action));
action.sa_handler = sig_handler;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
/* restart property */
action.sa_flags |= SA_RESTART;
sigaction(SIGUSR2, &action, NULL);同步处理 sigwaitinfo：
void* sub_sig_handle_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() return err: %d; %s\n", errno, strerror(errno));
}
}
}在某个独立的线程中，循环调用sigwaitinfo检测是否有未处理的信号，有则主动调用信号处理函数
多线程信号继承：
1. 每个线程都有自己独立的signal mask，但所有线程共享进程的signal action
2. 主线程调用pthread_sigmask创建信号屏蔽策略，将被所有子线程继承
3. pthread_kill 发送的目的线程需要与调用线程再同一个进程之中
4. 跨进程发送信号使用kill 指定进程PID
5. 同步处理时，子线程sigaddset的信号必须是主线程sigaddset的子集
同步、异步处理共存：
1. 同样的信号同时都被同步异步所注册，同步优先级更高，将以同步方式处理
2. 不同信号可以被不同方式处理，比如同步处理SIGUSR1的同时可以异步处理SIGUSR2
测试例程：
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#define MUTIL_THREAD 1
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.
printf("<-- get sig %d\n", signum);
if (signum == SIGUSR1) {
printf("<--thread %ld, 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 %ld, receive SIGRTMIN No. %d\n", sig_ppid, k);
k++;
} else if (signum == SIGUSR2) {
printf("<--thread %ld, receive SIGUSR2\n", sig_ppid);
}
}
void* worker_thread()
{
pthread_t ppid = pthread_self();
pthread_detach(ppid);
int ret = 0;
struct timeval tv = {10, 0}; //10s
while (1) {
printf("I'm thread %ld, I'm alive\n", ppid);
tv.tv_sec = 10;
ret = select(0, NULL, NULL, NULL, &tv);
if(ret < 0)
printf("thread %ld interrupt by signal\n", ppid);
//sleep(10);
}
}
void* sigmgr_thread()
{
sigset_t waitset, oset;
siginfo_t info;
int rc;
pthread_t ppid = pthread_self();
pthread_detach(ppid);
#if MUTIL_THREAD
sigemptyset(&waitset);
sigaddset(&waitset, SIGRTMIN);
sigaddset(&waitset, SIGUSR1);
#else
struct sigaction action;
memset(&action, 0, sizeof(action));
action.sa_handler = sig_handler;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
/* restart property */
action.sa_flags |= SA_RESTART;
sigaction(SIGUSR2, &action, NULL);
#endif
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() return err: %d; %s\n", errno, strerror(errno));
}
}
}
int main()
{
sigset_t bset, oset;
int i;
pid_t pid = getpid();
pthread_t ppid[7];
struct sigaction action;
memset(&action, 0, sizeof(action));
action.sa_handler = sig_handler;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
/* restart property */
action.sa_flags |= SA_RESTART;
#if MUTIL_THREAD
sigaddset(&action.sa_mask, SIGRTMIN);
sigaddset(&action.sa_mask, SIGUSR1); //handle by sub-thread
// sigaddset(&action.sa_mask, SIGUSR2);
if(pthread_sigmask(SIG_BLOCK, &action.sa_mask, &oset) != 0)
printf("!! Set pthread mask failed\n");
sigaction(SIGUSR2, &action, NULL); //handle by main
#else
sigaction(SIGUSR1, &action, NULL);
sigaction(SIGRTMIN, &action, NULL); //only main
#endif
printf("main pid %d, %ld\n", pid, pthread_self());
// Create the dedicated thread sigmgr_thread() which will handle
// SIGUSR1 and SIGRTMIN synchronously
pthread_create(&ppid[0], 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[i+1], NULL, worker_thread, NULL);
}
//wait sub-thread to regist signal
sleep(3);
// send out 50 SIGUSR1 and SIGRTMIN signals
for (i = 0; i < 5; i++) {
printf("\n-->main thread, send SIGUSR1 No. %d\n", i);
kill(pid, SIGUSR1);
printf("-->main thread, send SIGRTMIN No. %d\n", i);
kill(pid, SIGRTMIN);
printf("-->main thread, send SIGUSR2 No. %d\n", i);
kill(pid, SIGUSR2);
sleep(1);
}
struct timeval tv = {50, 0};
int ret = select(0, NULL, NULL, NULL, &tv);
if(ret < 0)
printf("main interrupt by signal\n");
return 0;
}
运行结果：
main pid 12018, 140114995099392
I'm thread 140114978449152, I'm alive
I'm thread 140114970056448, I'm alive
I'm thread 140114953271040, I'm alive
I'm thread 140114944878336, I'm alive
I'm thread 140114961663744, I'm alive-->main thread, send SIGUSR1 No. 0
-->main thread, send SIGRTMIN No. 0
-->main thread, send SIGUSR2 No. 0
<-- get sig 12
<--thread 140114995099392, receive SIGUSR2 --->主线程处理USR2
<--sigwaitinfo() fetch the signal 10
<-- get sig 10
<--thread 140114986841856, receive SIGUSR1 No. 0 -->同步处理信号
<--sigwaitinfo() fetch the signal 34
<-- get sig 34
<--thread 140114986841856, receive SIGRTMIN No. 0 -->同步处理信号-->main thread, send SIGUSR1 No. 1
-->main thread, send SIGRTMIN No. 1
-->main thread, send SIGUSR2 No. 1
<--sigwaitinfo() fetch the signal 10
<-- get sig 10
<--thread 140114986841856, receive SIGUSR1 No. 1
<--sigwaitinfo() fetch the signal 34
<-- get sig 34
<--thread 140114986841856, receive SIGRTMIN No. 1
<-- get sig 12
<--thread 140114995099392, receive SIGUSR2