【APUE | 10】函数signal

函数signal

函数signal介绍

typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
signal函数
    作用1：站在应用程序的角度，注册一个信号处理函数
    作用2：忽略信号，设置信号默认处理 信号的安装和回复
参数
--signal是一个带signum和handler两个参数的函数，准备捕捉或屏蔽的信号由参数signum给出，接收到指定信号时将要调用的函数有handler给出
--handler这个函数必须有一个int类型的参数（即接收到的信号代码），它本身的类型是void
--handler也可以是下面两个特殊值：① SIG_IGN 屏蔽该信号        ② SIG_DFL 恢复默认行为

 SIGCHLD信号

通过 signal(SIGCHLD, SIG_IGN) 通知内核对子进程的结束不关心，由内核回收。

• 如果不想让父进程挂起，可以在父进程中加入一条语句：  signal(SIGCHLD, SIG_IGN); 表示父进程忽略SIGCHLD信号。
• SIGCHLD信号：该信号是子进程退出的时候向父进程发送的。 子进程结束时, 父进程会收到这个信号。 

如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程 来接管)。

1. 测试代码

//忽略，屏蔽信号
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <signal.h>

int main(int arg, char *args[])
{
    pid_t pid=fork();
    if(pid == -1)
    {
        printf("fork() failed! error message:%s
",strerror(errno));
        return -1;
    }
    //注册信号，屏蔽SIGCHLD信号，子进程退出，将不会给父进程发送信号，因此也不会出现僵尸进程
    signal(SIGCHLD,SIG_IGN);
    if(pid > 0)
    {
        printf("father is runing !
");
        sleep(10);
    }
    if(pid == 0)
    {
        printf("i am child!
");
        exit(0);
    }
    printf("game over!
");
    return 0;
}

2. 测试代码

//恢复信号
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <signal.h>

void catch_signal(int sign)
{
    switch (sign)
    {
    case SIGINT:
        printf("ctrl + C 被执行了!
");
        //exit(0);
        break;
    }
}

int main(int arg, char *args[])
{
    //注册终端中断信号
    signal(SIGINT, catch_signal);
    char tempc = 0;
    while ((tempc = getchar()) != 'a')
    {
        printf("tempc = %d
", tempc);
        //sleep()
    }
    //恢复信号
    signal(SIGINT, SIG_DFL);
    while (1)
    {
        pause();
    }
    printf("game over!
");
    return 0;
}

输出结果：

不可靠信号

什么是不可靠信号：不可靠的意思是信号可能丢失或者被错误处理。

在早起系统中，信号存在两大缺陷，导致了信号不可靠。

 

一、缺陷一：

信号发生后，信号处理方式被重置为系统默认动作。依旧是说，signal函数知识把信号和我们的信号处理函数关联一次，在发生一次信号后，信号的处理方式就被重置为系统默认了。

这就导致了信号处理函数必须使用如下代码：

int  sig_int(); 
...
signal(SIGINT, sig_int); /*①1establish handler*/    
...
sig_int()
{
signal(SIGINT, sig_int); //②为了捕捉下一个信号 
...
./*process the signal ... */
...
}

我们不得不在信号处理函数中再次使用signal()。

    但是，这样的处理并不能保证程序完全正确，因为在发生一次信号时，在我们开始调用sig_int函数，到执行sig_int函数中的signal函数（也就是我们②代码）之间是有时间间隔的.如果在这段时间间隔里发生了再次发生了信号，那么针对这个信号的处理方式就是系统默认的方法了。

    所以早期的信号时不可靠的，因为他不能保证信号都使用正确的（我们期望的）处理方式进行处理。

二、缺陷二：

信号对进程的控制能力差： 早期系统实现中，当我们不希望信号发生时，进程无法关闭一个 信号，并在记录它的发生。

很多时候我们有这样的需求，我们不希望信号打断某项的工作，但是当工作执行完后，又希望系统告诉我们这段时间内发生了什么信号。比如我们运行一段程序，要求运行完之前不能中断它（比如我们的Ctl+C），这是就需要暂时关闭这个信号。 首先我们明确需求，我们需要的是，信号暂时不起作用，并在之后能够提醒我们信号发生过。

 为了实现这一点，我们使用下面代码

int  sig_int();     /* my signal handling function */
int  sig_int_flag; /* set nonzero when signal occurs */
main()
{
    signal(SIGINT, sig_int); /* establish handler */
    ...
    while (sig_int_flag == 0)
        pause();  /* go to sleep, waiting for signal */
    ...
}
sig_int()
{
    signal(SIGINT, sig_int); /* reestablish handler for next time */
    sig_int_flag = 1; /* set flag for main loop to examine */
}

  sig_int只有两行代码，它的作用就是忽略信号，并且用sig_int_flag标志信号发生过。

可重入函数

使用可重入函数进行更安全的信号处理

 

1.测试代码

#include<stdio.h>
#include<signal.h>

int value = 0;

void fun() {
    int i = 0;
    while (i++<5) {
        value++;
        printf("value is %d
", value);
        sleep(1);
    }
}
int main()
{
    signal(2, fun);
    fun();
    printf("the value is %d
", value);
    return 0;
}

输出结果：

参考资料

1. APUE学习笔记——10 信号