1、信号
首先信号我们要和信号量区分开来，虽然两者都是操作系统进程通信的方式。可以简单的理解，信号是用来通知进程发生了什么需要做什么，信号量一般是用作进程同步（pv操作）
2、常见信号量
（以下数字标号代表信号再bitmap中的位置）
２SIGINT 可能使我们最常用的信号之一。一般在我们想进程中断，键盘输入Ctrl + C 即可实现，这是一个进程终止信号。
３ SIGQUIT程序异常退出信号和2 类似， 输入Ctrl + 实现
４SIGILL 执行了非法指令. 通常是因为可执行文件本身出现错误, 或者试图执行数据段. 堆栈溢出时也有可能产生这个信号。
11SIGSEGV试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据.和SIGILL一样，程序出BUG时，我们经常见到。
17 SIGCHLD 子进程结束时, 父进程会收到这个信号。如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。
这种情况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程来接管)。后面会详细介绍。
19 SIGSTOP 停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略. GDB中就使用了该信号。
20 SIGIO 文件描述符准备就绪, 可以开始进行输入/输出操作.
3、信号常见操作
我们从进程说起，在进程的控制块中（PCB）有两个表一个叫做信号未决表，一个叫做信号阻塞表（都是64位图存储）。内核首先根据信号阻塞表中屏蔽状态字判断是否需要阻塞，如果该信号被设为为了阻塞的，那么信号未决表中对应 状态字（pending）相应位制成1；若该信号阻塞解除，信号未
决状态字（pending）相应位制成0；表示信号此时可以抵达了，也就是可以接收该信号了。其实由这个地方我们可以看到，同一个时刻，如果一个信号为阻塞了，那么无论你到来了多少次，在解除阻塞的时候进程只会处理一次。
备注： 阻塞意味着，信号到了，我暂时不处理，放着就是。 信号忽略，进程看到了，但是什么都不会做。
由此可见，对于信号而言，要么直接处理，要么一会处理(也有可能一直不处理)， 要么压根就不会处理。
我们看下系统中内置的API接口：
int sigemptyset(sigset_t *set);//将信号集清空，共64bits
int sigfillset(sigset_t *set);//将信号集置1
int sigaddset(sigset_t *set, int signum);//将signum对应的位置为1
int sigdelset(sigset_t *set, int signum);//将signum对应的位置为0
int sigismember(const sigset_t *set, int signum);//判断signum是否在该信号集合中，如果集合中该位为1，则返回1，表示位于在集合中
// 读取更改屏蔽状态字的API函数
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
/*
参数how有下面三种取值：
SIG_BLOCK： 将参数set指向的信号集中设置的信号添加到现在的屏蔽状态字中，设置为阻塞；
SIG_UNBLOCK：将参数set指向的信号集中设置的信号添加到现在的屏蔽状态字中，设置为非阻塞， 也就是解除阻塞；
SIG_SETMASK：将参数set指向的信号集直接覆盖现在的屏蔽状态字的值；
如果oset是非空指针，则读取进程的当前信号屏蔽字通过oset参数传出。
若成功则为0，若出错则为-1
*/
#include <signal.h>
#include <unistd.h>
using namespace std;
void Handle(int sig) {
printf("sig = %d
", sig);
abort();
}
void Prints(sigset_t* set) {
for (int i = 1; i <= 31; ++i) {
if (sigismember(set, i)) {
printf("1");
} else {
printf("0");
}
}
printf("
");
}
int main(){
signal(SIGINT, Handle);
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGQUIT);
sigprocmask(SIG_BLOCK, &set, NULL);
// signal(SIGINT, SIG_IGN); //忽略信号操作。
int i = 5;
while(i) {
i--;
sigset_t p;
sigpending(&p); // 获得当前信号未决表的数据。
Prints(&p);
sleep(2);
}
sigprocmask(SIG_UNBLOCK, &set, NULL);
//sigprocmask(SIG_UNBLOCK, &set, NULL);
//sigset_t p;
//sigpending(&p);
//Prints(&p);
printf("-1----------------------");
printf("-2----------------------");
printf("-3----------------------");
printf("-4----------------------");
return 0;
}
在上面代码中，signal(SIGINT, Handle)，我们自己注册了处理信号的函数。先展示结果：
0000000000000000000000000000000
0000000000000000000000000000000
^C0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
sig = 2
简单解释一下，按下ctrl + c 给进程传入了中断的信号，在map中位置为2的地方置为了1，因为我们阻塞了信号，所以他不做处理。
等在循环结束以后我们解除了屏蔽，系统调用了我们注册的函数，进行了信号处理，在处理函数中我们调用了abort，所以剩下的代码并没有执行。
如果我们把代码中的注释打开再编译运行，发现是下面的结果：
0000000000000000000000000000000
0000000000000000000000000000000
^C0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
0000000000000000000000000000000
-1-----------------------2-----------------------3-----------------------4----------------------
可以看到，SIGINT信号，到的时候，不是先忽略，是先判定阻塞，放在了未决信号表中。
然后等信号解阻塞以后，可以看到，进程忽略了该信号。不做处理。
4、SIGCHLD信号
这个信号，我们上面解释说明过。子进程退出时，会给父进程发送这个命令，让父进程回收资源。如果父进程不做处理，那么就成了子进程就成了我们说的僵尸进程，造成内存泄漏（敲黑板，这玩意也会造成内存泄漏）。
如果子进程退出的时候，父进程早就没了，那么回收资源的工作交给init进程。一般情况下，如果父进程，不关心子进程的资源回收，也不期待从儿子那边获得什么，可以对这个信号进行忽略，像上面代码中那样操作即可
signal(SIGCHLD, SIG_IGN)。这样也不会产生僵尸进程，子进程退出的时候，发个信号给父进程。父进程处理方式是忽略，子进程就自己退出了。
当然也可以自己创建处理函数，处理该信号。
在引入代码之前我们先说两个函数：wait 和 waitpid
头文件sys/wait.h
pid_t wait(int *status);
进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。
参数status用来保存被收集进程退出时的一些状态，它是一个指向int类型的指针。但如果我们对这个子进程是如何死掉的毫不在意，只想把这个僵尸进程消灭掉，（事实上绝大多数情况下，我们都会这样想），我们就可以设定这个参数为NULL，就象下面这样： pid = wait(NULL);
pid_t waitpid(pid_t pid, int *status, int options);
参数:
status:如果不是空，会把状态信息写到它指向的位置，与wait一样
options：允许改变waitpid的行为，最有用的一个选项是WNOHANG,它的作用是防止waitpid把调用者的执行挂起
The value of options is an OR of zero or more of the following con-
stants:
WNOHANG return immediately if no child has exited.
wait与waitpid区别：
在一个子进程终止前， wait 使其调用者阻塞，而waitpid 有一选择项，可使调用者不阻塞。
waitpid并不等待第一个终止的子进程—它有若干个选择项，可以控制它所等待的特定进程。
实际上wait函数是waitpid函数的一个特例。waitpid(-1, &status, 0);
了解这些以后我们看代码例子：
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
void waitchildren(int signo) {
int status;
wait(&status);
//while(1)waitpid(-1, &status, WNOHANG); //注释3
//while(1)wait(&status) //注释4
}
int main() {
int i;
pid_t pid;
//signal(SIGCHLD, waitchildren); //注释1
//signal(SIGCHLD, SIG_IGN); //注释2
for(i=0; i<100; i++) {
pid = fork();
if(pid == 0)
break;
}
if(pid>0) {
printf("press Enter to exit...");
getchar();
}
return 0;
}
如果 我们编译运行，发现在不退出的情况下，重新开一个终端运行top命令，可以看到zombie字段为100.即是100个僵尸进程。
如果打开注释1 发现还是有僵尸进程，但是数量不为100，同一时刻，很多子进程退出，但是可惜只处理一部分。
关闭注释1打开注释2.发现一个僵尸进程都没了。
如果只打开注释3 你也会发现一个僵尸进程都没了。
如果你只打开注释4，你会发现程序只处理了一个，而且卡死了。
wait 我们可以称其为同步接口，而waitpid为异步接口。
再看下面这段代码：
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
int count = 0;
void waitchildren(int signo) {
count++;
std::cout << count << "------------" << std::endl;
int status;
wait(&status);
}
int main() {
int i;
pid_t pid;
signal(SIGCHLD, waitchildren);
//signal(SIGCHLD, SIG_IGN);
sigset_t set;
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, NULL);
for(i=0; i<100; i++) {
pid = fork();
if(pid == 0)
break;
}
if(pid>0) {
printf("press Enter to exit...");
getchar();
sigprocmask(SIG_UNBLOCK, &set, NULL);
}
return 0;
}
这段程序你会发现，只有一个子进程发送的信号，被捕获处理了。
以上就是全部内容，欢迎各位大佬，纠错指正。