devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Linux后端服务器开发】信号量与信号_信号和信号量

作者：神奇cpp | 2024-07-04 02:37:01

赞

踩

信号和信号量

目录

一、信号量概述

二、信号概述

三、信号产生

1、终端按键产生信号

2、调用系统函数产生信号

3、硬件异常产生信号

4、软件条件

四、信号保存

1、信号阻塞

2、信号捕捉流程

五、信号递达

一、信号量概述

  • 信号量：一个计数器，通常用来表示公共资源中，资源数量的多少
  • 公共资源：能够被多个进程同时访问的资源
  • 访问没有被保护的公共资源：数据不一致
  • 被保护的公共资源：临界资源
  • 资源(内存、文件、网络......)是要被使用的，一定有该进程对应的代码来访问这部分临界资源(临界区)，不访问临界资源的代码是非临界区
  • 如何保护公共资源：互斥 && 同步
  • 所有进程在访问公共资源之前，都需要先申请sem信号量 ---> 信号量本身就是一个公共资源
  • 公共资源的使用：1. 作为一个整体使用；2. 划分为一个个子资源使用
  • 进程预定公共资源，信号量sem--（P操作）；进程释放公共资源，信号量sem++（V操作）；若信号量sem == 0，进程无法预定公共资源
  • 信号量的 --、++ 操作是原子性的（要么不执行，要么执行完）

申请信号量

控制信号量

设置信号量（PV操作）

二、信号概述

信号与信号量的关系，就如同老婆和老婆饼的关系，没有任何关系。

[1, 31]是普通信号，[34, 64]是实时信号

  • 进程本身是被程序员编写的属性和逻辑的集合 ------ 程序员编码完成
  • 当进程收到信号的时候，进程可能正在执行更重要的代码，信号不一定会被立即处理
  • 进程本身要有对应信号的保存能力
  • 进程对信号的三种处理方式：默认、自定义、忽视 ------ 信号被捕捉
  • 进程对信号的保存：task_struct中用位图结构保存
  • 发送信号的本质：修改pcb中的信号位图
  • pcb是内核维护的数据结构对象，由os管理
  • 所有发送信号的方式，本质都是os向目标进程发信号: os向用户提供发送信号的系统调用

三、信号产生

1、终端按键产生信号

  1. #include <iostream>
  2. #include <unistd.h>
  3. using namespace std;
  4.  
  5. int main() 
  6. {
  7.     while (1) 
  8.     {
  9.         cout << "this is a process, pid = " << getpid() << endl;
  10.         sleep(1);
  11.     }
  12.     return 0;
  13. }

键盘按键 ctrl C ---> os将ctrl+C解释为2号信号(SIGINT) ---> 进程终止

自定义捕捉方法

signal函数的调用，并不是自定义捕捉方法函数的直接调用

仅仅设置了对目标信号的捕捉方法，该方法并不一定会被调用

这个自定义捕捉方法只有收到了捕捉信号的时候才会被调用

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <signal.h>
  4. using namespace std;
  5.  
  6. void Handler(int signo) 
  7. {
  8.     cout << "进程捕捉到了一个信号，信号编号是：" << signo << endl;
  9. }
  10.  
  11. int main() 
  12. {
  13.     signal(2, Handler);
  14.  
  15.     while (1) 
  16.     {
  17.         cout << "this is a process, pid = " << getpid() << endl;
  18.         sleep(1);
  19.     }
  20.     return 0;
  21. }

当自定义2号信号(SIGINT)的捕捉方法之后，进程收到2号信号并不会终止，而是执行自定义捕捉方法的打印函数

2、调用系统函数产生信号

  • kill() 可以向任意进程发送任意信号
  • raise() 可以向自身进程发送任意信号 ----- kill(getpid(), signal)
  • abort() 给自己发送指定的信号SIGABRT ----- kill(getpid(), SIGABRT)

mykill.cc

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <signal.h>
  4. #include <cstdio>
  5. using namespace std;
  6.  
  7. static void Usage(const string& proc) 
  8. {
  9.     cout << "\nUsage: " << proc << "pid signo\n" << endl;
  10. }
  11.  
  12. void Handler(int signo) 
  13. {
  14.     cout << "进程捕捉到了一个信号，信号编号是：" << signo << endl;
  15. }
  16.  
  17. int main(int argc, char* argv[]) 
  18. {
  19.     if (argc != 3) 
  20.     {
  21.         Usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     pid_t pid = atoi(argv[1]);
  25.     int signo = atoi(argv[2]);
  26.     int n = kill(pid, signo);
  27.     if (n != 0) 
  28.         perror("kill");
  29.  
  30.     return 0;
  31. }

test.cc 一个死循环进程

  1. #include <iostream>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. using namespace std;
  5.  
  6. int main() 
  7. {
  8.     while (true) 
  9.     {
  10.         cout << "我是一个正在运行的进程，pid：" << getpid() << endl;
  11.         sleep(1);
  12.     }
  13.     return 0;
  14. }

myraise.cc

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <signal.h>
  4. #include <sys/types.h>
  5. #include <cstdio>
  6. using namespace std;
  7.  
  8. int main() 
  9. {
  10.     int cnt = 0;
  11.     while (true) 
  12.     {
  13.         printf("cnt: %d\n", cnt++);
  14.         sleep(1);
  15.         if (cnt >= 5) 
  16.         {
  17.             raise(9);
  18.             //abort();
  19.         }
  20.     }
  21.     return 0;
  22. }

5s后进程被自己发送的信号杀死（或放弃）

3、硬件异常产生信号

SIGFPE

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. using namespace std;
  6.  
  7. int main() 
  8. {
  9.     while (true) 
  10.     {
  11.         cout << "我在运行中..." << endl;
  12.         sleep(1);
  13.         int a = 10;
  14.         a /= 0;         
  15.     }
  16.  
  17.     return 0;
  18. }

除0 浮点数错误SIGFPE

获取信号编号

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. using namespace std;
  6.  
  7. void CatchSig(int signo) 
  8. {
  9.     cout << "获取一个信号，信号编号是：" << signo << endl;
  10.     sleep(1);
  11. }
  12.  
  13. int main() 
  14. {
  15.     signal(SIGFPE, CatchSig);
  16.  
  17.     while (true) 
  18.     {
  19.         cout << "我在运行中..." << endl;
  20.         sleep(1);
  21.         int a = 10;
  22.         a /= 0;         //除0 浮点数报错
  23.     }
  24.  
  25.     return 0;
  26. }

  • os通过状态寄存器当中的溢出标记位判断cpu是否发生运算异常，若产生异常，os发送信号
  • 进程收到信号，不一定会立即执行
  • cpu每次切换进程时进行上下文保存和恢复，os都会检测一次异常

4、软件条件

设置闹钟，进程1s之后结束，统计cnt累加次数

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. using namespace std;
  6.  
  7. int main() 
  8. {
  9.     alarm(1);
  10.     int cnt = 0;
  11.     while (1) 
  12.     {
  13.         cout << "cnt: " << cnt++ << endl;
  14.     }
  15.  
  16.     return 0;
  17. }

将cnt定义为全局重新，用捕捉信号重新定义

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. #include <cstdlib>
  6. using namespace std;
  7.  
  8. int cnt = 0;
  9.  
  10. void CatchSig(int signo) 
  11. {
  12.     cout << "cnt: " << cnt << endl;
  13. }
  14.  
  15. int main(int argc, char* argv[]) 
  16. {
  17.     signal(SIGALRM, CatchSig);
  18.     alarm(1);
  19.     while (1) 
  20.     {
  21.         cnt++;
  22.     }
  23.  
  24.     return 0;
  25. }

由此可见计算机将数据从内存打印到外设时间损耗巨大，IO效率很低

闹钟是一次性闹钟，执行之后不再执行

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. #include <cstdlib>
  6. using namespace std;
  7.  
  8. static int cnt = 0;
  9.  
  10. void CatchSig(int signo) 
  11. {
  12.     cout << "cnt: " << cnt << endl;
  13.     alarm(1);
  14. }
  15.  
  16. int main(int argc, char* argv[]) 
  17. {
  18.     signal(SIGALRM, CatchSig);
  19.     alarm(1);
  20.     while (1) 
  21.         cnt++;
  22.  
  23.     return 0;
  24. }

任何一个进程都可以通过alarm()系统调用设置闹钟，操作系统如何管理闹钟？先描述，再组织

核心转储

部分服务器默认关闭了核心转储

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main(int argc, char* argv[]) 
  5. {
  6.     //核心转储
  7.     while (1) 
  8.     {
  9.         int a[10];
  10.         a[100000] = 100;
  11.     }
  12.  
  13.     return 0;
  14. }

越界访问，不仅报了段错误，还生成了core.30202文件

以Term退出的没有核心转储

核心转储：当进程出现异常的时候，将进程在对应的时刻，在内存中的数据转储到磁盘中

核心转储意义：支持调试（事后调试）

对所有信号做自定义捕捉测试

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. #include <cstdlib>
  6. #include <sys/types.h>
  7. using namespace std;
  8.  
  9. void CatchSig(int signo) 
  10. {
  11.     cout << "收到一个信号，信号编号是：" << signo << endl;
  12. }
  13.  
  14. int main(int argc, char* argv[]) 
  15. {
  16.     for (int signo = 31; signo >= 1; --signo) 
  17.         signal(signo, CatchSig);
  18.  
  19.     while (1) 
  20.     {
  21.         cout << "我在运行, pid = " << getpid() << endl;
  22.         sleep(1);
  23.     }
  24.     return 0;
  25. }

只有9号信号可杀死进程（9号进程由os直接控制，禁止对9号信号做捕捉）

四、信号保存

  • 执行信号的处理动作称之为信号递达
  • 信号从产生到递达之间的状态叫做信号未决
  • 进程可以选择阻塞某个信号
  • 被阻塞的信号永远不会递达，除非进程接触阻塞
  • 阻塞和忽视是有不同的，忽视是递达之后的一种处理动作

1、信号阻塞

每个信号都有两个标志位表示阻塞(block)和未决(pending)，还有一个函数指针表示处理动作

如果一个信号没有产生，可以预先将它设为阻塞状态

2、信号捕捉流程

信号产生的时候，不会被立即处理，而是在从内核态返回用户态的时候进行处理

用户想要访问内核或硬件资源，必须通过系统调用完成访问

CPU中存在CR3表态寄存器，表示当前运行的运行级别：0表示内核态，3表示用户态

每一个进程都有自己的地址空间（用户空间独占）、内核空间（被映射到每一个进程的3~4G）

进程要访问OS的接口，只需要在自己的地址空间上进行跳转

每一个进程都会共享一个内核级页表，无论进程如何切换，不会更改内核空间

系统调用接口，起始位置会将我们的用户权限更改为内核态（陷入内核）

特定的身份调用特定的代码，内核态也无法直接调用用户态状态

信号捕捉流程图

五、信号递达

sigprocmask读取或更改进程的信号屏蔽字

sigpending获取进程的pending位图

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. #include <cstdlib>
  6. #include <sys/types.h>
  7. #include <vector>
  8. using namespace std;
  9.  
  10. static vector<int> sigarr = {2, 3};
  11.  
  12. void ShowPending(const sigset_t& pending) 
  13. {
  14.     for (int signo = 31; signo >= 1; signo--) {
  15.         if (sigismember(&pending, signo)) 
  16.             cout << "1";
  17.         else 
  18.             cout << "0";
  19.     }
  20.     cout << endl;
  21. }
  22.  
  23. void MyHandler(int signo) 
  24. {
  25.     cout << signo << " 号信号已经被递达\n" << endl;
  26. }
  27.  
  28. int main(int argc, char* argv[]) 
  29. {
  30.     for (const auto& e : sigarr) 
  31.         signal(e, MyHandler);
  32.  
  33.     // 1. 屏蔽指定的信号
  34.     sigset_t block, oblock, pending;
  35.     // 1.1 初始化
  36.     sigemptyset(&block);
  37.     sigemptyset(&oblock);
  38.     // 1.2 添加要屏蔽的信号
  39.     for (const auto& e : sigarr) 
  40.         sigaddset(&block, e);   // 2号信号
  41.     // 1.3 开始屏蔽
  42.     sigprocmask(SIG_SETMASK, &block, &oblock);
  43.  
  44.     // 2. 遍历打印pending信号集
  45.     int cnt = 10;
  46.     while (1) 
  47.     {
  48.         sigemptyset(&pending);
  49.         sigpending(&pending);
  50.         ShowPending(pending);
  51.         sleep(1);
  52.         if (cnt-- == 0) 
  53.         {
  54.             cout << "恢复对信号的屏蔽\n" << endl;
  55.             sigprocmask(SIG_SETMASK, &oblock, &block);
  56.         }
  57.     }
  58.  
  59.     return 0;
  60. }

将2号、3号信号屏蔽

ctrl C + ctrl \ 发送2号信号和3号信号，信号未决，pending位图2号和3号bit位置1

10s后重置对信号的屏蔽，os直接将重置的信号递达，捕捉到2号、3号信号

sigaction

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <vector>
  5. using namespace std;
  6.  
  7. void ShowPending(const sigset_t& pending) 
  8. {
  9.     for (int signo = 31; signo >= 1; signo--) 
  10.     {
  11.         if (sigismember(&pending, signo)) 
  12.             cout << "1";
  13.         else 
  14.             cout << "0";
  15.     }
  16.     cout << endl;
  17. }
  18.  
  19. void MyHandler(int signo) 
  20. {
  21.     cout << "get a signo: " << signo << endl;
  22. }
  23.  
  24. int main(int argc, char* argv[]) 
  25. {
  26.     struct sigaction act, oact;
  27.     act.sa_handler = MyHandler;
  28.     act.sa_flags = 0;
  29.     sigemptyset(&act.sa_mask);
  30.     sigaction(SIGINT, &act, &oact);
  31.  
  32.     while (true);
  33.  
  34.     return 0;
  35. }

进程串行处理同类信号

  1. #include <iostream>
  2. #include <signal.h>
  3. #include <unistd.h>
  4. #include <cstdio>
  5. #include <cstdlib>
  6. using namespace std;
  7.  
  8. void Count(int cnt) 
  9. {
  10.     while (cnt) 
  11.     {
  12.         printf("cnt: %d\n", cnt);
  13.         fflush(stdout);
  14.         cnt--;
  15.         sleep(1);
  16.     }
  17. }
  18.  
  19. void MyHandler(int signo) 
  20. {
  21.     cout << "get a signo: " << signo << endl;
  22.     Count(10);
  23. }
  24.  
  25. int main(int argc, char* argv[]) 
  26. {
  27.     struct sigaction act, oact;
  28.     act.sa_handler = MyHandler;
  29.     act.sa_flags = 0;
  30.     sigemptyset(&act.sa_mask);
  31.     sigaddset(&act.sa_mask, 3);     //在2号信号捕捉期间，屏蔽3号信号
  32.     sigaction(SIGINT, &act, &oact);
  33.  
  34.     while (true) sleep(1);
  35.  
  36.     return 0;
  37. }

  • 当进程正在递达某一个信号期间，同类信号无法被递达
  • 当当前信号正在被捕捉，系统自动将当前信号加入到进程的信号屏蔽字，当捕捉完成，系统又自动解除对该信号的屏蔽
  • 一般一个信号被解除屏蔽的话，会自动递达当前屏蔽信号
  • 进程处理信号的原则是串行处理同类信号，不允许递归处理

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/785387
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号