总结：sigprocmask修改block表；sigpending读取 pending表；signal修改hander表

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include using namespace std;int cnt = 0;void handler(int signo)
{cout << "我是一个进程，刚刚获取了一个信号: " << signo << " cnt: " << cnt << endl;// exit(1);
}static void showPending(sigset_t *pendings)
{for (int sig = 1; sig <= 31; sig++){if (sigismember(pendings, sig)){cout << "1";}else{cout << "0";}}cout << endl;
}int main(int argc, char *argv[])
{cout << "pid: " << getpid() << endl;sigset_t bsig, obsig;sigemptyset(&bsig);sigemptyset(&obsig);// sigfillset();for (int sig = 1; sig <= 31; sig++)  //将当前进程阻塞所有信号，并注册所有信号{sigaddset(&bsig, sig);signal(sig, handler);}// 设置用户级的信号屏蔽字到内核中sigprocmask(SIG_SETMASK, &bsig, &obsig);// 1. 不断的获取当前进程的pending信号集sigset_t pendings;int cnt = 0;while (true){// 1.1 清空信号集sigemptyset(&pendings);// 1.2 获取当前进程(谁调用，获取谁)的pending信号集if (sigpending(&pendings) == 0){// 1.3 打印一下刚刚获取到的当前进程的pengding信号集showPending(&pendings);}sleep(1);cnt++;    if(cnt == 20)    //第20秒时解除2号信号的阻塞{cout << "解除对2号信号的block...." << endl;sigset_t sigs;sigemptyset(&sigs);sigaddset(&sigs, 2);sigprocmask(SIG_UNBLOCK, &sigs, nullptr);}}

六.信号的捕捉（信号处理后）

进程处理信号，不是立即处理的。
合适的时候，是什么时候呢? ?——当当前进程从内核态，切换回用户态的时候，进行信号的检测与处理! 先解释用户态和内核态：

1.用户态和内核态

①OS在不在内存中被加载呢? ?——在
无论进程怎么切换，我们都可以找到内核的代码和数据,前提是你只要能够有权利访问!

②当前进程如何具备权利 访问这个内核页表乃至访问内核数据呢?——要进行身份切换。
        进程如果是用户态的——>只能访问用户级页表 0~3G
        进程如果是内核态的——>访问内核级和用户级的页表 3~4G
③我怎么知道我是用户态的还是内核态的呢?
CPU内部有对应的状态寄存器CR3, CR3有比特位标识当前进程的状态 0:内核态，3:用户态

④0—>3 切到内核态的情况：1.系统调用的时候。2.时间片到了，进程间切换。3.其他等等。执行完毕就继续切回用户态

⑤内核态vs用户态
内核态可以访问所有的代码和数据——内核态具备更高权限
用户态只能访问自己的

⑥我们的程序，会无数次直接或者间接的访问系统级软硬件资源(管理者是OS)，本质上，你并没有自己去操作这些软硬件资源，而是必须通过OS- >无数次的陷入内核(1.切换身份3->0 2.切换页表，切到内核级页表)->调用内核的代码->完成访问的动作->结果返回给用户(1.切换身份0->3 2. 切换页表，切到用户级页表)->用户得到结果

⑦while(1);死循环进程普通程序会身份切换吗？ —>也会陷入内核，来回切换身份 —>你也有自己的时间片 —>时间片到了的时候->OS收到中断信息，把进程从cpu移走，进程切到内核态，更换内核级页表 —>保护上下文，执行调度算法 —>选择了新的进程 —>恢复新进程的上下文 —>用户态，更换成用户级页表 —>CPU执行的就是新进程的代码!
 

2.自定义捕捉信号的处理过程

①因为一些系统调用例如open()，用户态—>内核态，处理完open的代码后

②本来可以返回代码继续执行了，但是正好处于内核态，就顺便去检测信号，并处理信号。

③处理信号：若是阻塞或无信号(忽略/默认)就直接进行对应简答操作就 内核态—>用户态 返回即可 / 若是非阻塞并有信号的自定义捕捉，就 内核态—>用户态 执行对应的handler方法。（执行handler方法为什么只能是用户态？解释：内核态是什么都可以做的，如果让内核态做用户自定义代码，万一用户写的是一段恶意代码呢? ? ?比如rm根目录等等，这样内核态身份就被恶意利用了，所以内核为了保护自己，就只能用户态执行用户的代码）

④执行完信号对应方法后再由 用户态—>内核态 回到内核。此时所有任务都完成：系统接口调用完成，信号捕捉完成。

⑤完成所有任务后，由  内核态—>用户态 通过特殊系统调用返回到当时用户跳出的代码中。

结论：进程的生命周期中，会有很多次机会去陷入内核(中断，陷阱，系统调用，异常...),一定会存在很多次的机会进行内核态返回用户态。进程的信号在被合适的时候处理，合适的时候：从内核态返回到用户态的时候，返回之前顺便检测信号，并处理信号

过程图，跟上面一样，可以忽略：

记忆图 ：无穷大画法

无穷大中间交点要在横线下方，则有多少个交点，就证明有多少个状态切换；方向决定了 是内核到用户，还是用户到内核

3.第二个捕捉函数 sigaction

（1）sigaction介绍

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

 signum：要对哪个信号自定义捕捉。act：设置成什么动作。oldact：老动作，输出型参数，不要就设置nullptr

只用填sa_handler，sa_mask，2个 ，sa_flags 默认为0不考虑，其他是实时信号的也不考虑、

sa_handler：注册信号的函数处理方法

sa_ mask ——作用：执行某①信号处理函数时，信号集位图sa_ mask中有某②信号，阻塞①信号同时，阻塞 sa_ mask 传入的②信号——（2）是详细解释

 例1

例2

 killall mysignal——根据进程名杀进程

 （2）sa_mask 解释

sa_ mask ——作用：执行某①信号处理函数时，信号集位图sa_ mask中有某②信号，阻塞①信号同时，阻塞 sa_ mask 传入的②信号

  ctrl c后再ctrl c发现2号信号为1，即：阻塞了2号信号。sigaddset(&act.sa_ mask，3) ; 信号集位图中有3号信号，作用是执行2号信号时阻塞了2号信号同时也阻塞3号信号

（3）handler可以配合使用switch语句：

void Handler2(){cout << "hello 2" << endl;}void Handler3(){cout << "hello 3" << endl;}void Handler4(){cout << "hello 4" << endl;}void Handler5(){cout << "hello 5" << endl;}void Handler(int signo){switch (signo){case 2:Handler2();break;case 3:Handler3();break;case 4:Handler4();break;case 5:Handler5();break;default:break;}}int main(){signal(2, Handler);signal(3, Handler);signal(4, Handler);signal(5, Handler);while (1){sleep(1);}}

4.可重入函数

main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的 时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler函 数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入节点node2操作的 两步都做完之后从 sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步，之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只有一个节点node1真正插入链表中了，node2会内存泄漏。

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,即：不能多个执行流调用，被像这样的函数称为 不可重入函数(大部分都是)。反之, 如果一个函数只访问自己的局部变量或参数,在重复被多个执行流调用时不会出现问题，则称为可重入(Reentrant) 函数。想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

5.volatile

作用：保持内存的可见性，读取必须从内存中读

（1）常规情况（无-O2优化，无volatile）

正常makefile中 不加-O2 也不加volatile 是和(2)一样的结果，都能把flags修改而终止进程。

（2）优化情况（有-O2优化，无volatile）

但是makefile加了-O2，表明让编译器优化：因为while(!flags)是位运算，只能CPU处理，而且flags一直在被使用，此时CPU自作主张把内存中的flags放入寄存器中，当我们修改flags=1时，只是修改了内存中的flags，没有影响寄存器中的flags，则ctrl c 时执行处理方法，但是寄存器中的flags不会改变，永远不会终止进程。

 （3）优化+volatile 情况（有-O2优化，有volatile）

volatile：保持内存的可见性，读取必须从内存中读

此时要求CPU每次使用flags只能从内存中拿flags放入寄存器中，这样修改flags就可以终止进程。

七.SIGCHLD信号

1.子进程在 终止/暂停（stop）/继续运行时 会给父进程发SIGCHLD信号

 测试：

#include 
#include 
#include using namespace std;void handler(int signo)
{cout << "子进程退出啦，我确实收到了信号: " << signo << " 我是: " << getpid() << endl;
}int main()
{signal(SIGCHLD, handler);pid_t id = fork();if (id == 0){while (true){cout << "我是子进程: " << getpid() << endl;sleep(1);}exit(0);}// parentwhile (true){cout << "我是父进程: " << getpid() << endl;sleep(1);}
}

（1）进程退出会发信号

 （2）进程 暂停（stop）/继续运行 会发信号

2.

等一个进程waitpid的第一个参数就传-1，可以等待任意进程退出就回收 

如果10个进程同时退出，在执行方法时会阻塞该信号的多次发出，所以只能捕捉一个信号，导致其他信号丢失，则其他僵尸进程无法捕捉

58:50 图：使用子进程给父进程发送SIGCILD：10个进程先退7个，waitpid(-1,nullptr,WNOHANG)

1:4：45 下面这个代码：父进程调 用sigaction将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。

    // signal(SIGCHLD, FreeChld);
    // 子进程退出的时候，默认的信号处理就是忽略吗？
    // 调用signal/sigaction SIG_IGN, 意义在哪里呢？
    // SIG_IGN手动设置，操作系统自动设置：让子进程退出不要给父进程发送信号了，并且自动释放，子进程不会僵尸

#include 
#include 
#include 
#include 
#include 
#include 
#include using namespace std;void FreeChld(int signo)
{assert(signo == SIGCHLD);while (true){// waitpid 什么时候调用失败呢？如果你已经没有子进程了// -1: 等待任意一个子进程pid_t id = waitpid(-1, nullptr, WNOHANG); // bug?？if (id > 0){cout << "父进程等待成功, chld pid: " << id << endl;}else if(id == 0){//还有子进程，但是现在没有退出cout << "还有子进程，但是现在没有退出, 父进程要去忙自己的事情了" << endl;break;}else{cout << "父进程等待所有子进程结束" << endl;break;}}
}int main()
{// signal(SIGCHLD, FreeChld);// 子进程退出的时候，默认的信号处理就是忽略吗？// 调用signal/sigaction SIG_IGN, 意义在哪里呢？// SIG_IGN手动设置，让子进程退出，不要给父进程发送信号了，并且自动释放signal(SIGCHLD, SIG_IGN);for (int i = 0; i < 10; i++){pid_t id = fork();if (id == 0){//子进程int cnt = 10;// if (i < 7)//     cnt = 5;// else//     cnt = 20;while (cnt){cout << "我是子进程, pid: " << getpid() << " 当前的cnt: " << cnt-- << endl;sleep(1);}cout << "子进程退出，进入僵尸状态" << endl;exit(0);}// sleep(1);}while (true){cout << "我是父进程，我正在运行: " << getpid() << endl;sleep(1);}// //父进程,都是要自己主动等待// if(waitpid(id, nullptr, 0) > 0)// {//     cout << "父进程等待子进程成功" << endl;// }return 0;
}