细说linux IPC（七）：信号（上）

时间：2014-11-24 20:53:36 阅读：293 评论：0 收藏：0 [点我收藏+]

信号类似于中断请求，一个进程不会阻塞在某处等待信号的到来，也不会知道信号何时能到来，信号的产生是随机的，进程只需要注册信号处理函数，在信号到来时执行信号处理函数即可。

linux系统支持的信号可以通过命令kill -l来查看：

# kill -l 
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM 
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ 
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR 
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8 
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13 
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12 
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 
63) SIGRTMAX-1 64) SIGRTMAX 
#

其中SIGRTMIN 前面信号是早期UNIX支持的信号，是不可靠信号，后面信号（SIGRTMIN 到SIGRTMAX ）为后期添加，为可靠信号。在linux上信号是否可靠主要体现在信号是否支持排队，不支持排队的信号可能会丢失。

信号的产生可能有很多，比如：

1. 用户按下CTRL+C是产生中断信号（SIGINT ）；

2. 硬件异常产生信号，比如除数为0，非法访问内存（SIGSEGV ）等；

3. 使用系统命令发送信号，如kill -s <signo> <pid>，将发送值为signo的信号给进程号为pid的进程；

4.调用kill函数等其他可以发送信号的函数，给指定进程发送信号。可以发送信号的函数有：alarm（）和setitimer（）发送SIGALRM信号，abort（）发送SIGABRT 信号，raise给进程自身发送任意信号，kill函数给其它进程或自身进程发送任意信号。

进程收到信号处理方式有三种：

1. 忽略信号；大多数信号可以忽略，但两种信号除外：SIGKILl和SIGSTOP。

2.执行系统默认操作；大部分信号的默认操作是终止该进程。

3.捕捉信号并执行信号处理函数；即在收到信号时，执行用户自己定义的函数。

注册信号处理函数可以使用函数signal：

       #include <signal.h>
       typedef void (*sighandler_t)(int);
       sighandler_t signal(int signum, sighandler_t handler);

参数signum是将要注册处理函数的信号，handler是对信号（参数一）的处理函数或SIG_IGN或SIG_DFL，如果为参数SIG_DFL，进程收到信号时将执行默认操作，如果为SIG_IGN时进程将忽略信号，如果为信号处理函数，进程收到信号时会执行该函数，并将参数一signum传给该函数；

发送信号可以使用kill函数：

       #include <sys/types.h>
       #include <signal.h>
       int kill(pid_t pid, int sig);

参数pid为要发送给信号的目标进程id，sig为将要发送的信号，当为0时（即空信号），实际不发送任何信号，但照常进行错误检查，因此，可用于检查目标进程是否存在，以及当前进程是否具有向目标发送信号的权限（root权限的进程可以向任何进程发送信号，非root权限的进程只能向属于同一个session或者同一个用户的进程发送信号）。

参数pid的值	信号的接收进程
pid>0	进程ID为pid的进程
pid=0	同一个进程组的进程
pid<-1	进程组ID为 -pid的所有进程
pid=-1	除进程1外，所有有向目标进程发送信号权限的进程

既然是说IPC，那就举一个父子进程通过信号来实现简单通信的程序，即父进程向子进程发送信号，子进程收到信号后执行信号处理函数。

void sig_func(int signo)
{
    printf("====%s== [child] handle signo: %d===\n", __func__, signo);
}

void child_process_do(void)
{
    printf("====%s==child pid: %d===\n", __func__, getpid());

    signal(SIGRTMIN, sig_func); //子进程注册信号SIGRTMIN处理函数sig_func
    //signal(SIGALRM, sig_func);

    while (1) {
        sleep(10);
    }
}

void parent_process_do(pid_t pid)
{
    int i;

    sleep(1); //等待子进程先注册完信号处理函数，否则系统如果先调用父进程先执行，在调用kill之后子进程会退出，看不到我们需要的效果
    printf("====%s==parent pid: %d===\n", __func__, getpid());

    for (i = 0; i < 5; i++) {
        printf("====%s==[parent] send signal <%d> to pid <%d>==\n", __func__, SIGRTMIN, pid);
        kill(pid, SIGRTMIN); //父进程连续每隔一秒向子进程发一个SIGRTMIN信号
        //kill(pid, SIGALRM);
        sleep(1);
    }

    waitpid(pid, NULL, 0); //父进程等待子进程结束
}


int main(int argc, const char *argv[])
{
    pid_t pid;

    pid = fork();
    if (pid < 0) {
        fprintf(stderr, "fork: %s\n", strerror(errno));
        return -1;
    }
    if (0 == pid) {
        child_process_do(); //子进程
    } else {
        parent_process_do(pid); //父进程
    }

    return 0;
}

运行时，父进程发5个信号给子进程，子进程收到并处理。

# ./target_bin

====child_process_do==child pid: 7072===

====parent_process_do==parent pid: 7071===

====parent_process_do==[parent] send signal <34> to pid <7072>==