信号

信号是事件发生时对进程的通知机制，也可以把它称为软件中断。信号与硬件中断的相似之处在于能够打断程序当前执行的正常流程，其实是在软件层次上对中断机制的一种模拟。大多数情况下，是无法预测信号达到的准确时间，所以，信号提供了一种处理异步事件的方法。

产生信号的方式：

⚫ 硬件发生异常，即硬件检测到错误条件并通知内核，随即再由内核发送相应的信号给相关进程。硬件检测到异常的例子包括执行一条异常的机器语言指令，诸如，除数为 0、数组访问越界导致引用了无法访问的内存区域等，这些异常情况都会被硬件检测到，并通知内核、然后内核为该异常情况发生时正在运行的进程发送适当的信号以通知进程。
⚫ 用于在终端下输入了能够产生信号的特殊字符。譬如在终端上按下 CTRL + C 组合按键可以产生中断信号（SIGINT），通过这个方法可以终止在前台运行的进程；按下 CTRL + Z 组合按键可以产生暂停信（SIGCONT），通过这个方法可以暂停当前前台运行的进程。
⚫ 进程调用 kill()系统调用可将任意信号发送给另一个进程或进程组。当然对此是有所限制的，接收信号的进程和发送信号的进程的所有者必须相同，亦或者发送信号的进程的所有者是 root 超级用户。
⚫ 用户可以通过 kill 命令将信号发送给其它进程。kill 命令想必大家都会使用，通常我们会通过 kill命令来“杀死”（终止）一个进程，譬如在终端下执行”kill -9 xxx”来杀死 PID 为 xxx 的进程。kill命令其内部的实现原理便是通过 kill()系统调用来完成的。
⚫ 发生了软件事件，即当检测到某种软件条件已经发生。这里指的不是硬件产生的条件（如除数为 0、引用无法访问的内存区域等），而是软件的触发条件、触发了某种软件条件（进程所设置的定时器已经超时、进程执行的 CPU 时间超限、进程的某个子进程退出等等情况）

通常进程会视具体信号执行以下操作之一：
⚫ 忽略信号。也就是说，当信号到达进程后，该进程并不会去理会它、直接忽略，就好像是没有出该信号，信号对该进程不会产生任何影响。事实上，大多数信号都可以使用这种方式进行处理，但有两种信号却决不能被忽略，它们是 SIGKILL 和 SIGSTOP，这两种信号不能被忽略的原因是：它们向内核和超级用户提供了使进程终止或停止的可靠方法。另外，如果忽略某些由硬件异常产生的信号，则进程的运行行为是未定义的。
⚫ 捕获信号。当信号到达进程后，执行预先绑定好的信号处理函数。为了做到这一点，要通知内核在某种信号发生时，执行用户自定义的处理函数，该处理函数中将会对该信号事件作出相应的处理，Linux 系统提供了 signal()系统调用可用于注册信号的处理函数，将会在后面向大家介绍。
⚫ 执行系统默认操作。进程不对该信号事件作出处理，而是交由系统进行处理，每一种信号都会有其对应的系统默认的处理方式，8中对此有进行介绍。需要注意的是，对大多数信号来说，系统默认的处理方式就是终止该进程。

实时信号与非实时信号其实是从时间关系上进行的分类，与可靠信号与不可靠信号是相互对应的，非实时信号都不支持排队，都是不可靠信号；实时信号都支持排队，都是可靠信号。实时信号保证了发送的多个信号都能被接收，实时信号是 POSIX 标准的一部分，可用于应用进程。

Linux 下对标准信号（不可靠信号、非实时信号）的编号为 1~31。

进程对信号的处理

signal函数

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

signum：此参数指定需要进行设置的信号，可使用信号名（宏）或信号的数字编号，建议使用信号名。
handler：sig_t 类型的函数指针，指向信号对应的信号处理函数，当进程接收到信号后会自动执行该处理函数；参数 handler 既可以设置为用户自定义的函数，也就是捕获信号时需要执行的处理函数，也可以设置为 SIG_IGN 或 SIG_DFL，SIG_IGN 表示此进程需要忽略该信号，SIG_DFL 则表示设置为系统默认操作。
sig_t 函数指针的 int 类型参数指的是，当前触发该函数的信号，可将多个信号绑定到同一个信号处理函数上，此时就可通过此参数来判断当前触发的是哪个信号。

返回值：此函数的返回值也是一个 sig_t 类型的函数指针，成功情况下的返回值则是指向在此之前的信号处理函数；如果出错则返回 SIG_ERR，并会设置 errno。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
static void sig_handler(int sig)
{
 	printf("Received signal: %d\n", sig);
}
int main(int argc, char *argv[])
{
 	sig_t ret = NULL;
 	ret = signal(SIGINT, (sig_t)sig_handler);
 	if (SIG_ERR == ret) 
 	{
		perror("signal error");
 		exit(-1);
 	}
 /* 死循环 */
 	for ( ; ; ) { }
 	exit(0);
}

sigaction()函数

#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

signum：需要设置的信号，除了 SIGKILL 信号和 SIGSTOP 信号之外的任何信号。
act：act 参数是一个 struct sigaction 类型指针，指向一个 struct sigaction 数据结构，该数据结构描述了信
号的处理方式，稍后介绍该数据结构；如果参数 act 不为 NULL，则表示需要为信号设置新的处理方式；如
果参数 act 为 NULL，则表示无需改变信号当前的处理方式。
oldact：oldact 参数也是一个 struct sigaction 类型指针，指向一个 struct sigaction 数据结构。如果参数
oldact 不为 NULL，则会将信号之前的处理方式等信息通过参数 oldact 返回出来；如果无意获取此类信息，
那么可将该参数设置为 NULL。
返回值：成功返回 0；失败将返回-1，并设置 errno。

struct sigaction 
{
 	void (*sa_handler)(int);
 	void (*sa_sigaction)(int, siginfo_t *, void *);
 	sigset_t sa_mask;
 	int sa_flags;
 	void (*sa_restorer)(void);
};

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
static void sig_handler(int sig)
{
 	printf("Received signal: %d\n", sig);
}
int main(int argc, char *argv[])
{
 	struct sigaction sig = {0};
 	int ret;
 	sig.sa_handler = sig_handler;
 	sig.sa_flags = 0;
 	ret = sigaction(SIGINT, &sig, NULL);
 	if (-1 == ret) 
    {
 		perror("sigaction error");
 		exit(-1);
 	}
 	/* 死循环 */
 	for ( ; ; ) { }
 	exit(0);
}

向进程发信号

kill函数

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

pid：参数 pid 为正数的情况下，用于指定接收此信号的进程 pid；除此之外，参数 pid 也可设置为 0 或-1 以及小于-1 等不同值，稍后给说明。
sig：参数 sig 指定需要发送的信号，也可设置为 0，如果参数 sig 设置为 0 则表示不发送信号，但任执行错误检查，这通常可用于检查参数 pid 指定的进程是否存在。
返回值：成功返回 0；失败将返回-1，并设置 errno。
参数 pid 不同取值含义：
⚫ 如果 pid 为正，则信号 sig 将发送到 pid 指定的进程。
⚫ 如果 pid 等于 0，则将 sig 发送到当前进程的进程组中的每个进程。
⚫ 如果 pid 等于-1，则将 sig 发送到当前进程有权发送信号的每个进程，但进程 1（init）除外。
⚫ 如果 pid 小于-1，则将 sig 发送到 ID 为-pid 的进程组中的每个进程。
进程中将信号发送给另一个进程是需要权限的，并不是可以随便给任何一个进程发送信号，超级用户root 进程可以将信号发送给任何进程，但对于非超级用户（普通用户）进程来说，其基本规则是发送者进程的实际用户 ID 或有效用户 ID 必须等于接收者进程的实际用户 ID 或有效用户 ID。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
 	int pid;
 /* 判断传参个数 */
 	if (2 > argc)
 		exit(-1);
 /* 将传入的字符串转为整形数字 */
	 pid = atoi(argv[1]);
 	printf("pid: %d\n", pid);
 /* 向 pid 指定的进程发送信号 */
 	if (-1 == kill(pid, SIGINT)) 
    {
 		perror("kill error");
 		exit(-1);
 	}
 	exit(0);
}

raise()函数

#include <signal.h>
int raise(int sig);

sig：需要发送的信号。
返回值：成功返回 0；失败将返回非零值。
raise()其实等价于：kill(getpid(), sig);

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
static void sig_handler(int sig)
{
 	printf("Received signal: %d\n", sig);
}
int main(int argc, char *argv[])
{
 	struct sigaction sig = {0};
 	int ret;
 	sig.sa_handler = sig_handler;
 	sig.sa_flags = 0;
 	ret = sigaction(SIGINT, &sig, NULL);
 	if (-1 == ret) 
 	{
 		perror("sigaction error");
 		exit(-1);
 	}
 	for ( ; ; ) 
 	{
 	/* 向自身发送 SIGINT 信号 */
 		if (0 != raise(SIGINT)) 
 		{
 			printf("raise error\n");
 			exit(-1);
 		}
 		sleep(3); // 每隔 3 秒发送一次
 	}
 	exit(0);
}

alarm()和 pause()函数

使用 alarm()函数可以设置一个定时器（闹钟），当定时器定时时间到时，内核会向进程发送 SIGALRM信号

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

seconds：设置定时时间，以秒为单位；如果参数 seconds 等于 0，则表示取消之前设置的 alarm 闹钟。
返回值：如果在调用 alarm()时，之前已经为该进程设置了 alarm 闹钟还没有超时，则该闹钟的剩余值作为本次 alarm()函数调用的返回值，之前设置的闹钟则被新的替代；否则返回 0。参数 seconds 的值是产生 SIGALRM 信号需要经过的时钟秒数，当这一刻到达时，由内核产生该信号，每个进程只能设置一个 alarm 闹钟；虽然 SIGALRM 信号的系统默认操作是终止进程，但是如果程序当中设置了 alarm 闹钟，但大多数使用闹钟的进程都会捕获此信号。
需要注意的是 alarm 闹钟并不能循环触发，只能触发一次，若想要实现循环触发，可以在 SIGALRM 信号处理函数中再次调用 alarm()函数设置定时器。

pause()系统调用可以使得进程暂停运行、进入休眠状态，直到进程捕获到一个信号为止，只有执行了信
号处理函数并从其返回时，pause()才返回，在这种情况下，pause()返回-1，并且将 errno 设置为 EINTR。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
static void sig_handler(int sig)
{
	puts("Alarm timeout");
}
int main(int argc, char *argv[])
{
 	struct sigaction sig = {0};
 	int second;
 /* 检验传参个数 */
 	if (2 > argc)
 		exit(-1);
 /* 为 SIGALRM 信号绑定处理函数 */
 	sig.sa_handler = sig_handler;
 	sig.sa_flags = 0;
 	if (-1 == sigaction(SIGALRM, &sig, NULL)) 
 	{
 		perror("sigaction error");
 		exit(-1);
 	}
 /* 启动 alarm 定时器 */
 	second = atoi(argv[1]);
 	printf("定时时长: %d 秒\n", second);
 	alarm(second);
 /* 进入休眠状态 */
 	pause();
 	puts("休眠结束");
 	exit(0);
}

信号集

有一个能表示多个信号（一组信号）的数据类型—信号集（signalset），很多系统调用都使用到了信号集这种数据类型来作为参数传递，譬如 sigaction()函数、sigprocmask()函数、sigpending()函数等。

信号集其实就是 sigset_t 类型数据结构

# define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
	unsigned long int __val[_SIGSET_NWORDS];
} sigset_t;

使用这个结构体可以表示一组信号，将多个信号添加到该数据结构中，当然 Linux 系统了用于操作sigset_t 信号集的 API，譬如 sigemptyset()、sigfillset()、sigaddset()、sigdelset()、sigismember()。

信号集处理

初始化sigemptyset()和 sigfillset()

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);

函数参数和返回值含义如下：
set：指向需要进行初始化的信号集变量。
返回值：成功返回 0；失败将返回-1，并设置 errno。

sigset_t sig_set;
sigemptyset(&sig_set);
sigset_t sig_set;
sigfillset(&sig_set);

添加和删除信号

#include <signal.h>
int sigaddset(sigset_t *set, int signum);//set指向信号集，signum需要添加和删除的信号
int sigdelset(sigset_t *set, int signum);//成功返回 0；失败将返回-1，并设置 errno。

sigset_t sig_set;
sigemptyset(&sig_set);
sigaddset(&sig_set, SIGINT);//信号集添加信号

sigset_t sig_set;
sigfillset(&sig_set);
sigdelset(&sig_set, SIGINT);//信号集移除信号

测试信号是否在信号集

#include<signal.h>
int sigismember(const sigset_t *set, int signum);
//set：指定信号集。
//signum：需要进行测试的信号。
//返回值：如果信号 signum 在信号集 set 中，则返回 1；如果不在信号集 set 中，则返回 0；失败则返回1，并设置 errno。

eg:

sigset_t sig_set;
if(sigismember(&sig_set, SIGINT) == 1)
	puts("信号集中包含SIGINT信号");

在 Linux 下，每个信号都有一串与之相对应的字符串描述信息，用于对该信号进行相应的描述。这些字符串位于 sys_siglist 数组中，sys_siglist 数组是一个 char *类型的数组，数组中的每一个元素存放的是一个字符串指针，指向一个信号描述信息。譬如，可以使用 sys_siglist[SIGINT]来获取对 SIGINT 信号的描述。

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
 	printf("SIGINT 描述信息: %s\n", sys_siglist[SIGINT]);
 	printf("SIGQUIT 描述信息: %s\n", sys_siglist[SIGQUIT]);
 	printf("SIGBUS 描述信息: %s\n", sys_siglist[SIGBUS]);
 	exit(0);
}

psignal()可以在标准错误（stderr）上输出信号描述信息

#include <signal.h>
void psignal(int sig, const char *s);

信号掩码（阻塞信号传递）

内核为每一个进程维护了一个信号掩码（其实就是一个信号集），即一组信号。当进程接收到一个属于信号掩码中定义的信号时，该信号将会被阻塞、无法传递给进程进行处理，那么内核会将其阻塞，直到该信号从信号掩码中移除，内核才会把该信号传递给进程从而得到处理。

信号掩码中添加信号的方法：

①程序调用signal()或者sigaction函数为某一个信号设置处理方式时，进程会自动将该信号添加到信号掩码中，这样保证了处理一个给定信号时候，再次碰到该信号，会将请其阻塞。

②使用sigaction()函数为信号设置处理方式时，可以额外指定一组信号，当调用信号处理函数时将该组信号自动添加到信号掩码中，但信号处理函数结束返回后，再将这组信号从信号掩码中移除

③还可以使用sigprocmask()系统调用，随时可以显式地向信号掩码中添加/移除信号。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

how：参数 how 指定了调用函数时的一些行为。
set：将参数 set 指向的信号集内的所有信号添加到信号掩码中或者从信号掩码中移除；如果参数 set 为NULL，则表示无需对当前信号掩码作出改动。
oldset：如果参数 oldset 不为 NULL，在向信号掩码中添加新的信号之前，获取到进程当前的信号掩码，存放在 oldset 所指定的信号集中；如果为 NULL 则表示不获取当前的信号掩码。
返回值：成功返回 0；失败将返回-1，并设置 errno。
参数 how 可以设置为以下宏：
⚫ SIG_BLOCK：将参数 set 所指向的信号集内的所有信号添加到进程的信号掩码中。换言之，将信号掩码设置为当前值与 set 的并集。
⚫ SIG_UNBLOCK：将参数 set 指向的信号集内的所有信号从进程信号掩码中移除。
⚫ SIG_SETMASK：进程信号掩码直接设置为参数 set 指向的信号集。

#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<unistd.h>
static void sig_handler(int sig)
{
    printf("执行信号处理函数\n");
}
int main(void)
{
 	struct sigaction sig = {0};
 	sigset_t sig_set;
 /* 注册信号处理函数 */
 	sig.sa_handler = sig_handler;
 	sig.sa_flags = 0;
 	if (-1 == sigaction(SIGINT, &sig, NULL))
 		exit(-1);
 /* 信号集初始化 */
 	sigemptyset(&sig_set);
 	sigaddset(&sig_set, SIGINT);
 /* 向信号掩码中添加信号 */
 	if (-1 == sigprocmask(SIG_BLOCK, &sig_set, NULL))
 		exit(-1);
 /* 向自己发送信号 */
 	raise(SIGINT);
 /* 休眠 2 秒 */
 	sleep(2);
 	printf("休眠结束\n");
 /* 从信号掩码中移除添加的信号 */
 	if (-1 == sigprocmask(SIG_UNBLOCK, &sig_set, NULL))
 	exit(-1);
 	exit(0);
}

阻塞等待信号

如果希望对一个信号解除阻塞后，然后调用 pause()以等待之前被阻塞的信号的传递，这将如何？譬如有如下代码段：

sigset_t new_set, old_set;
 /* 信号集初始化 */
 sigemptyset(&new_set);
 sigaddset(&new_set, SIGINT);
 /* 向信号掩码中添加信号 */
 if (-1 == sigprocmask(SIG_BLOCK, &new_set, &old_set))
 exit(-1);
 /* 受保护的关键代码段 */
 ......
 /**********************/
 /* 恢复信号掩码 */
 if (-1 == sigprocmask(SIG_SETMASK, &old_set, NULL))
 exit(-1);
 pause();/* 等待信号唤醒 */

执行受保护的关键代码时不希望被 SIGINT 信号打断，所以在执行关键代码之前将 SIGINT 信号添加到进程的信号掩码中，执行完毕之后再恢复之前的信号掩码。最后调用了 pause()阻塞等待被信号唤醒，如果此时发生了信号则会被唤醒、从 pause 返回继续执行；考虑到这样一种情况，如果信号的传递恰好发生在第二次调用sigprocmask()之后、pause()之前，如果确实发生了这种情况，就会产生一个问题，信号传递过来就会导致执行信号的处理函数，而从处理函数返回后又回到主程序继续执行，从而进入到 pause()被阻塞，知道下一次信号发生时才会被唤醒，这有违代码的本意。

要避免这个问题，需要将恢复信号掩码和 pause()挂起进程这两个动作封装成一个原子操作，这正是 sigsuspend()系统调用的目的所在。

#include <signal.h>
int sigsuspend(const sigset_t *mask);

mask：参数 mask 指向一个信号集。
返回值：sigsuspend()始终返回-1，并设置 errno 来指示错误（通常为 EINTR），表示被信号所中断，如果调用失败，将 errno 设置为 EFAULT。

sigsuspend()函数会将参数 mask 所指向的信号集来替换进程的信号掩码，也就是将进程的信号掩码设置为参数 mask 所指向的信号集，然后挂起进程，直到捕获到信号被唤醒（如果捕获的信号是 mask 信号集中的成员，将不会唤醒、继续挂起）、并从信号处理函数返回，一旦从信号处理函数返回，sigsuspend()会将进程的信号掩码恢复成调用前的值。

调用 sigsuspend()函数相当于以不可中断（原子操作）的方式执行以下操作：

sigprocmask(SIG_SETMASK, &mask, &old_mask);
pause();
sigprocmask(SIG_SETMASK, &old_mask, NULL);

实时信号

确定进程中处于等待状态的是哪些信号，用sigpending()函数获取。

#include <signal.h>
int sigpending(sigset_t *set);

set：处于等待状态的信号会存放在参数 set 所指向的信号集中。
返回值：成功返回 0；失败将返回-1，并设置 errno。

判断 SIGINT 信号当前是否处于等待状态

/* 定义信号集 */
sigset_t sig_set;
/* 将信号集初始化为空 */
sigemptyset(&sig_set);
/* 获取当前处于等待状态的信号 */
sigpending(&sig_set);
/* 判断 SIGINT 信号是否处于等待状态 */
if (1 == sigismember(&sig_set, SIGINT))
puts("SIGINT 信号处于等待状态");
else if (!sigismember(&sig_set, SIGINT))
puts("SIGINT 信号未处于等待状态");

等待信号集只是一个掩码，仅表明一个信号是否发生，而不能表示其发生的次数。换言之，如果一个同一个信号在阻塞状态下产生了多次，那么会将该信号记录在等待信号集中，并在之后仅传递一次（仅当做发生了一次），这是标准信号的缺点之一。

实时信号较之于标准信号，其优势如下：
⚫ 实时信号的信号范围有所扩大，可应用于应用程序自定义的目的，而标准信号仅提供了两个信号可用于应用程序自定义使用：SIGUSR1 和 SIGUSR2。
⚫ 内核对于实时信号所采取的是队列化管理。如果将某一实时信号多次发送给另一个进程，那么将会多次传递此信号。相反，对于某一标准信号正在等待某一进程，而此时即使再次向该进程发送此信号，信号也只会传递一次。
⚫ 当发送一个实时信号时，可为信号指定伴随数据（一整形数据或者指针值），供接收信号的进程在它的信号处理函数中获取。
⚫ 不同实时信号的传递顺序得到保障。如果有多个不同的实时信号处于等待状态，那么将率先传递具有最小编号的信号。换言之，信号的编号越小，其优先级越高，如果是同一类型的多个信号在排队，那么信号（以及伴随数据）的传递顺序与信号发送来时的顺序保持一致。

应用程序当中使用实时信号，需要有以下的两点要求：
⚫ 发送进程使用 sigqueue()系统调用向另一个进程发送实时信号以及伴随数据。
⚫ 接收实时信号的进程要为该信号建立一个信号处理函数，使用sigaction函数为信号建立处理函数，并加入 SA_SIGINFO，这样信号处理函数才能够接收到实时信号以及伴随数据，也就是要使用sa_sigaction 指针指向的处理函数，而不是 sa_handler，当然允许应用程序使用 sa_handler，但这样就不能获取到实时信号的伴随数据了。

#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);

pid：指定接收信号的进程对应的 pid，将信号发送给该进程。
sig：指定需要发送的信号。与 kill()函数一样，也可将参数 sig 设置为 0，用于检查参数 pid 所指定的进程是否存在。
value：参数 value 指定了信号的伴随数据，union sigval 数据类型。

返回值：成功将返回 0；失败将返回-1，并设置 errno。

typedef union sigval
{
	int sival_int;
	void *sival_ptr;
} sigval_t;

异常退出函数abort()

使用 abort()终止进程运行，会生成核心转储文件，可用于判断程序调用 abort()时的程序状态

#include <stdlib.h>
void abort(void);

函数 abort()通常产生 SIGABRT 信号来终止调用该函数的进程，SIGABRT 信号的系统默认操作是终止进程运行、并生成核心转储文件；当调用 abort()函数之后，内核会向进程发送 SIGABRT 信号。