Linux 进程学习（三）

捕捉信号：
  
 
使用 signal 函数
 signal 函数是 Linux 系统上传统的信号处理接口：
 #include <signal.h>
 sighandler_t signal(int signum, sighandler_t handler);

 其中 sighandler_t 类型是一个函数指针类型，定义如下：
 typedef void (*sighandler_t)(int);

 这个类型表示一个信号处理函数。signal 函数的作用就是讲 handler 参数所指向的函数注册成为参数

signum 所代表的信号的处理函数，它的返回值是这个信号原来的处理函数，如果返回 SIG_ERR，则说明有错误发生，
注册失败。
 注册成功后，所注册的函数就会在信号被处理时调用，代替了默认的行为，或者成为信号被捕捉。 
 
 使用 signal 函数时应注意以下两点：
 ◆ handler 参数的值可以是 SIG_IGN 或者 SIG_DFL，SIG_IGN 表示忽略这个信号，SIG_DFL 表示对信号的处

理重设为系统的默认方式。
 ◆ 有些信号是不可以忽略或捕获的，如 SIGKILL 和 SIGSTOP。

 下面给出一个例程来说明信号的产生、忽略与捕获的编程，例程代码如下：

/* 文件名：sigtest.c */
/* 说明：信号处理例程 */

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>

static pid_t pid;

/* 子进程 1 SIGALRM 信号处理函数 */
static void wakeup(int dummy)
{
    printf("I (pid = %d) am up now\n",pid);
}

/* 子进程 1 SIGINT 信号处理函数 */
static void handler(int dummy)
{
    printf("I (pid = %d) got an interrupt, will exit\n",pid);
    exit(0);
}

/* 子进程 2 信号处理函数 */
static void trapper(int i)
{
    if(i == SIGUSR1)
    {
        printf("I (pid = %d) got SIGUSR1,will exit\n", pid);
        exit(0);
    }
    else
    {
        printf("I (pid = %d) got signal %d, will continue\n", pid, i);
    }
}


/* 父进程信号处理函数 */
void parent(int sig)
{
    printf("Signal (%d) received by parent (%d)\n", sig, pid);
}

int main(int argc, char *argv[])
{
    int i, cpid1, cpid2;
    
    printf("Number of signal is %d\n", NSIG);   //输出系统中信号的个数
    
    if(!(cpid1 = fork()))  //创建第一个子进程
    {
        pid = cpid1 = getpid();  //获得子进程的进程号
        printf("CPID1 = %d\n", cpid1);
        
        for(i=1; i<NSIG; i++)
        {
            signal(i, SIG_IGN);  //忽略所以的信号
        }
        
        signal(SIGINT, handler); //捕获信号 SIGINT
        signal(SIGALRM, wakeup); //捕获超时信号
        alarm(2);                //启动定时器，设置 2 秒后超时
        
        for(; ;)
        {
            pause();  //等待信号
        }
        
        printf(" -- CPID1 (%d) terminates\n", cpid1);
        
        exit(0);
    }
    else if(!(cpid2 = fork()))  //创建第二个子进程
    {
        pid = cpid2 = getpid();
        printf("CPID2 = %d\n", cpid2);
        
        for(i=1; i<NSIG; i++)
        {
            signal(i, trapper);  //捕获所有的信号
        }
        
        for(; ;)
        {
            pause();  //等待信号
        }
        
        printf(" -- CPID2 (%d) terminates\n", cpid2);
        
        exit(0);
    }
    
    /* 下面是父进程执行的代码 */
    pid = getpid();  //取得 PID
    sleep(3);        //睡眠，让子进程先运行
    printf("This is parent process (pid = %d)\n", pid);
    
    for(i=1; i<NSIG; i++)
    {
        signal(i, parent);  //捕获所以信号
    }
    
    printf("Send SIGUSR1(%d) to CPID1 (%d)\n", SIGUSR1, cpid1);
    kill(cpid1, SIGUSR1);
    printf("Send SIGINT(%d) to CPID1 (%d)\n", SIGINT, cpid1);
    kill(cpid1, SIGINT);
    printf("Send SIGINT(%d) to CPID2 (%d)\n", SIGBUS, cpid2);
    kill(cpid2, SIGINT);
    printf("Send SIGUSR1(%d) to CPID2 (%d)\n", SIGUSR1, cpid2);
    kill(cpid2, SIGUSR1);
    
    for(; wait((int *)0) > 0; );  //等待子进程结束
    
    return 0;
}

在这个例程中，父进程又创建了两个子进程，这三个进程分别注册或忽略了相关的信号，然后通过 alarm 函数设置超

时信号或通过 kill 函数发送信号。还用到了 pause 和 sleep 函数，如下：
 #include <unistd.h>
 int pause(void);
 unsigned int sleep(unsigned int seconds);

 pause 函数将使当前进程进入睡眠态，直到有信号发送。它的返回值永远是 -1，同时变量 errno 的值被设为

EINTR 以表示有信号发生。
 sleep 函数将使当前进程进入睡眠态，并在 seconds 参数指定的秒数后被唤醒继续执行。注意当有未忽略的

信号发生时 sleep 函数会提前返回，返回值是剩余的秒数。如果返回 0 则说明是正常被唤醒的，而不是因信号的发生

提前返回的。