信号、signal 函数、sigaction 函数

1.信号的基本概念

发送信号是进程之间常用的通信手段。信号用来通知某个进程发生了某一个事情，事情、信号都是突发事件，信号是异步发生的，信号也被称为“软件中断”。

信号如何产生：

• 某个进程发送给另外一个进程或者发送给自己
• 由内核发送给某个进程
  • 通过在键盘上输入命令，如 Ctrl + C、kill
  • 内存访问异常、除数为 $0$ 等等，硬件都会检测到并且通知内核

UNIX 以及类 UNIX 操作系统支持的信号数量各不相同。信号有名字，都是以 SIG 开头，如终端断开信号 SIGHUP。其实，信号就是一些宏定义的正整数常量（从数字 $1$ 开始）。

查找 signal.h 中 SIGHUP 的命令如下：

sudo find / -name "signal.h" | xargs grep -in "SIGHUP"

2.利用 kill 命令发送信号

创建一个 test.c 文件，其内容如下：

#include <stdio.h>
#include <unistd.h>

int main(int argc, char* const* argv)
{
    
    
    printf("你好，世界！\n");
    for (;;)
    {
    
    
        sleep(1);
        printf("休息1秒\n");
    }
    printf("程序退出，再见！\n");
    return 0;
}

编译 test.c 的命令如下：

gcc test.c -o test

运行 test 的命令如下：

./test

查看 bash 进程和 test 进程的命令如下：

ps -eo pid,ppid,pgid,sid,tty,comm | grep -E 'bash|PID|test'

跟踪 test 进程的命令如下：

sudo strace -e trace=signal -p 1268

kill 1268 命令就是往 test 进程发送 SIGTERM 终止信号：

kill -2 1365 命令就是往 test 进程发送 SIGINT 中断信号：

关于 kill 命令及 Linux 系统支持的部分信号：https://wker.com/linux-command/kill.html

3.信号处理的相关动作

上面提到的 kill 命令只是发个信号，而不是单纯的杀死的意思。

当某个信号出现时，我们可以按三种方式之一进行处理：

• 执行系统默认动作，绝大多数信号的默认动作是杀死这个进程；
• 忽略该信号；
• 捕捉该信号，即自己写个处理函数，当信号来的时候，就调用处理函数来处理。

注意：SIGKILL 和 SIGSTOP 信号既不能被忽略，也不能被捕捉。

4.信号与 signal 函数

进程：“嘿，操作系统！如果我之前创建的子进程终止，就帮我调用 zombie_handler 函数。”

操作系统：“好的！如果你的子进程终止，我会帮你调用 zombie_handler 函数，你先把该函数要执行的语句编好！”

上述对话中进程所讲的相当于“注册信号”过程，即进程发现自己的子进程结束时，请求操作系统调用特定函数。该请求通过 signal 函数调用完成，因此称 signal 函数为信号注册函数。

#include <signal.h>

void (*signal(int signo, void (*func)(int)))(int);

// 为了在产生信号时调用，返回之前注册的函数指针
// 函数名：signal
// 参数：int signo, void(*func)(int)
// 返回类型：参数为int型，返回void型函数指针

调用上述函数时，第一个参数为特殊情况信息，第二个参数为特殊情况下将要调用的函数的地址值（指针）。发生第一个参数代表的情况时，调用第二个参数所指的函数。

// 子进程终止则调用mychild函数
signal(SIGCHLD, mychild);
// 常数SIGCHLD定义了子进程终止的情况，应成为signal函数的第一个参数
// 此时mychild函数的参数应为int，返回值类型应为void，只有这样才能成为signal函数的第二个参数

// 已到通过alarm函数注册的时间，请调用timeout函数
signal(SIGALRM, timeout);

// 输入CTRL+C时调用keycontrol函数
signal(SIGINT, keycontrol);

以上就是信号注册过程。注册好信号后，发生注册信号时（注册的情况发生时），操作系统将调用该信号对应的函数。

4.1 signal 函数示例一

下面首先介绍 alarm 函数。

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

// 返回0或以秒为单位的距SIGALRM信号发生所剩时间

如果调用该函数的同时向它传递一个正整型参数，相应时间后（以秒为单位）将产生 SIGALRM 信号。若向该函数传递 $0$，则之前对 SIGALRM 信号的预约将取消。如果通过该函数预约信号后未指定该信号对应的处理函数，则（通过调用 signal 函数）终止进程，不做任何处理。

接下来给出信号处理相关示例。

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

// 定义信号处理函数，这种类型的函数称为信号处理器（Handler）
void timeout(int sig)
{
    
    
	if (sig == SIGALRM)
		puts("Time out!");
	
	// 为了每隔2秒重复产生SIGALRM信号，在信号处理器中调用alarm函数
	alarm(2);
}

// 定义信号处理函数，这种类型的函数称为信号处理器（Handler）
void keycontrol(int sig)
{
    
    
	if (sig == SIGINT)
		puts("CTRL+C pressed");
}

int main(int argc, char *argv[])
{
    
    
	int i;

	// 注册SIGALRM、SIGINT信号及相应处理器
	signal(SIGALRM, timeout);
	signal(SIGINT, keycontrol);
	
	// 预约2秒后发生SIGALRM信号
	alarm(2);

	// 为了查看信号产生和信号处理器的执行，提供每次100秒、共3次的等待时间，在循环中调用sleep函数。
	// 也就是说，再过300秒、约5分钟后终止程序，这是相当长的一段时间，但实际执行时只需不到10秒。
	for (i = 0; i < 3; i++)
	{
    
    
		puts("wait...");
		sleep(100);
	}

	return 0;
}

编译运行：

gcc signal.c -o signal
./signal

输出结果：

上述是没有任何输入时的运行结果。

下面在运行过程中输入 CTRL+C，可以看到输出“CTRL+C pressed”字符串。

有一点必须说明：“发生信号时将唤醒由于调用 sleep 函数而进入阻塞状态的进程。”

调用函数的主体的确是操作系统，但进程处于睡眠状态时无法调用函数。因此，产生信号时，为了调用信号处理器，将唤醒由于调用 sleep 函数而进入阻塞状态的进程。而且，进程一旦被唤醒，就不会再进入睡眠状态。即使还未到 sleep 函数中规定的时间也是如此。所以，上述示例运行不到 $10$ 秒就会结束，连续输入 CTRL+C 则有可能 $1$ 秒都不到。

4.2 signal 函数示例二

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>

// 信号处理函数
void sig_usr(int signo)
{
    
    
    if (signo == SIGUSR1)
    {
    
    
        printf("收到了SIGUSR1信号!\n");
    }
    else if (signo == SIGUSR2)
    {
    
    
        printf("收到了SIGUSR2信号!\n");
    }
    else
    {
    
    
        printf("收到了未捕捉的信号%d!\n", signo);
    }
}

int main(int argc, char* const* argv)
{
    
    
    // 系统函数，第一个参数是个信号，第二个参数是个函数指针，代表一个针对该信号的捕捉处理函数
    if (signal(SIGUSR1, sig_usr) == SIG_ERR)
    {
    
    
        printf("无法捕捉SIGUSR1信号!\n");
    }

    if (signal(SIGUSR2, sig_usr) == SIG_ERR)
    {
    
    
        printf("无法捕捉SIGUSR2信号!\n");
    }

    for (;;)
    {
    
    
        sleep(1);
        printf("休息1秒\n");
    }

    printf("再见!\n");

    return 0;
}

5.利用 sigaction 函数进行信号处理

sigaction 函数，它类似于 signal 函数，而且完全可以代替 signal 函数，也更稳定。之所以稳定，是因为：“signal 函数在 UNIX 系列的不同操作系统中可能存在区别，但 sigaction 函数完全相同。”

实际上现在很少使用 signal 函数编写程序，它只是为了保持对旧程序的兼容。下面介绍 sigaction 函数，但只讲解可替换 signal 函数的功能，因为全面介绍会给各位带来不必要的负担。

#include <signal.h>

int sigaction(int signo, const struct sigaction *act, struct sigaction *oldact);

// 成功时返回0，失败时返回-1。
// signo：与signal函数相同，传递信号信息。
// act：对应于第一个参数的信号处理函数（信号处理器）信息。
// oldact：通过此参数获取之前注册的信号处理函数指针，若不需要则传递0。

声明并初始化 sigaction 结构体变量以调用上述函数，该结构体定义如下：

struct sigaction
{
    
    
    void (*sa_handler)(int);
    sigset_t sa_mask;
    int sa_flags;
};

此结构体的 sa_handler 成员保存信号处理函数的指针值（地址值）。sa_mask 和 sa_flags 的所有位均初始化为 $0$ 即可。这 $2$ 个成员用于指定信号相关的选项和特性，而我们的目的主要是防止产生僵尸进程，故省略。

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

// #define _XOPEN_SOURCE 700

void timeout(int sig)
{
    
    
	if (sig == SIGALRM)
		puts("Time out!");

	alarm(2);
}

int main(int argc, char *argv[])
{
    
    
	int i;

	// 为了注册信号处理函数，声明sigaction结构体变量并在sa_handler成员中保存函数指针值
	struct sigaction act;
	act.sa_handler = timeout;

	// 调用sigemptyset函数将sa_mask成员的所有位初始化为0
	sigemptyset(&act.sa_mask);

	// sa_flags成员同样初始化为0
	act.sa_flags = 0;

	// 注册SIGALRM信号的处理器。调用alarm函数预约2秒后发生SIGALRM信号
	sigaction(SIGALRM, &act, 0);

	alarm(2);

	for (i = 0; i < 3; i++)
	{
    
    
		puts("wait...");
		sleep(100);
	}
	
	return 0;
}

编译运行：

gcc sigaction.c -o sigaction
./sigaction

输出结果：

6.利用信号处理技术消灭僵尸进程

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

// #define _XOPEN_SOURCE 700

void read_childproc(int sig)
{
    
    
	int status;
	pid_t id = waitpid(-1, &status, WNOHANG);
	if (WIFEXITED(status))
	{
    
    
		printf("Removed proc id: %d\n", id);
		printf("Child send: %d\n", WEXITSTATUS(status));
	}
}

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

	// 注册SIGCHLD信号对应的处理器。若子进程终止，则调用第7行中定义的函数。
	// 处理函数中调用了waitpid函数，所以子进程将正常终止，不会成为僵尸进程。
	struct sigaction act;
	act.sa_handler = read_childproc;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGCHLD, &act, 0);

	// 创建子进程
	pid = fork();

	if (pid == 0)    // 子进程执行区域
	{
    
    
		puts("Hi! I'm child process");
		sleep(10);
		return 12;
	}
	else    // 父进程执行区域
	{
    
    
		printf("Child proc id: %d\n", pid);

		// 创建子进程
		pid = fork();

		if (pid == 0)    // 另一个子进程执行区域
		{
    
    
			puts("Hi! I'm child process");
			sleep(15);
			exit(24);
		}
		else
		{
    
    
			int i;
			printf("Child proc id: %d\n", pid);

			// 为了等待发生SIGCHLD信号，使父进程共暂停5次，每次间隔5秒。
			// 发生信号时，父进程将被唤醒，因此实际暂停时间不到25秒。
			for (i = 0; i < 5; i++)
			{
    
    
				puts("wait...");
				sleep(5);
			}
		}
	}

	return 0;
}

编译运行：

gcc remove_zombie.c -o zombie
./zombie

输出结果：

可以看出，子进程并未变成僵尸进程，而是正常终止了。