发送信号是进程之间常用的通信手段。信号用来通知某个进程发生了某一个事情，事情、信号都是突发事件，信号是异步发生的，信号也被称为“软件中断”。
信号如何产生：
Ctrl + C、kill
UNIX 以及类 UNIX 操作系统支持的信号数量各不相同。信号有名字，都是以 SIG 开头，如终端断开信号 SIGHUP。其实，信号就是一些宏定义的正整数常量（从数字
1
1
1 开始）。
查找 signal.h 中 SIGHUP 的命令如下：
sudo find / -name "signal.h" | xargs grep -in "SIGHUP"
创建一个 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
上面提到的 kill 命令只是发个信号，而不是单纯的杀死的意思。
当某个信号出现时，我们可以按三种方式之一进行处理：
注意：SIGKILL 和 SIGSTOP 信号既不能被忽略，也不能被捕捉。
进程：“嘿，操作系统！如果我之前创建的子进程终止，就帮我调用 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);
以上就是信号注册过程。注册好信号后，发生注册信号时（注册的情况发生时），操作系统将调用该信号对应的函数。
下面首先介绍 alarm 函数。
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
// 返回0或以秒为单位的距SIGALRM信号发生所剩时间
如果调用该函数的同时向它传递一个正整型参数，相应时间后（以秒为单位）将产生 SIGALRM 信号。若向该函数传递 0 0 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 10 10 秒就会结束，连续输入 CTRL+C 则有可能 1 1 1 秒都不到。
#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;
}
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 0 0 即可。这 2 2 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
输出结果：
#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
输出结果：
可以看出，子进程并未变成僵尸进程，而是正常终止了。