• 操作系统——信号

    将信号分为以上四个阶段

    1.信号注册：是针对信号处理方式的规定，进程收到信号时有三种处理方式：默认动作，忽略，自定义动作。如果不是自定义动作，这一步可以忽略。这个步骤要使用到signal/sigaction接口

    2.信号产生：就是操作系统向进程发出信号 

    3.信号保存

    4.信号捕捉处理

    信号有哪些

    1-31是普通信号 34-62是实时信号 

    Action列指的是当信号被发送到一个进程时，默认操作系统采取的动作。具体的动作类型和含义如下：

    1. Term (Terminate)：

      • 终止进程。此操作表示操作系统将结束进程的执行。这是大多数信号的默认动作。

    2. Core (Terminate and Dump Core)：

    3. Ign (Ignore)：

      • 忽略信号。进程接收到信号时，操作系统不会采取任何动作，也不会通知进程。

    4. Stop：

      • 停止进程的执行。进程被暂停，直到接收到继续信号（如SIGCONT）。

    5. Cont (Continue)：

      • 继续执行被停止的进程。此操作恢复一个之前被暂停的进程的执行。

    理解信号

    信号和生活中的信号是一样的。例如下课铃声就是一个信号，上学的第一天，老师会告诉我们下课铃声响起的时候就可以下课休息——信号规定。当一节课的下课铃声响起，我们收到这个信号，但是老师想拖堂，我们先将这个信号保存到大脑，等老师讲完才会对下课信号处理。从下课铃声响起到真正下课这段时间就是时间窗口。信号产生了并不代表现在就要处理，进程会选择在合适的时间进行处理。

    信号注册

    signal

    signal是将signum这个信号的处理方式进行自定义

    注意：信号9和信号19不可以修改，因为进程终止和停止的权利必须由操作系统掌握

    例子：

    将信号1自定义捕捉

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7. void fun(int signum)
    8. {
    9.     cout << "get signum" << signum << endl;
    10. }
    11.  
    12. int main()
    13. {
    14.     signal(1,fun);
    15.     while(1)
    16.     {
    17.         cout << "process running pid:" << getpid() << endl;
    18.         sleep(1);
    19.     }
    20.     return 0;
    21. }

    运行程序发送信号1

    sigaction

    了解信号保存信号处理后再了解这个接口！！！！

    sigaction结构体中，第一个是自定义动作函数指针，第三个是处理信号时要屏蔽的信号，其他的暂时不考虑。

    act表示信号处理的方式，oact表示之前信号处理的方式。

    例子：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. void PrintPend(sigset_t& set)
    9. {
    10.     for(int signo = 31; signo >= 1; signo--)
    11.     {
    12.         if(sigismember(&set, signo)) cout << 1;
    13.         else cout << 0;
    14.     }
    15.     cout << endl;
    16. }
    17. void header(int sig)
    18. {
    19.     sigset_t set;
    20.     sigemptyset(&set);
    21.     while(1)
    22.     {
    23.         sigpending(&set);
    24.         PrintPend(set);
    25.         sleep(1);
    26.     }
    27. }
    28. int main()
    29. {
    30.     struct sigaction act,oact;
    31.     sigaddset(&act.sa_mask, 3);
    32.     sigaddset(&act.sa_mask, 4);
    33.     sigaddset(&act.sa_mask, 5);
    34.     act.sa_handler = header;
    35.     sigaction(SIGINT, &act, &oact);
    36.  
    37.     while(1)
    38.     {
    39.         cout << "process running:" << getpid() << endl;
    40.         sleep(1);
    41.     }
    42.     return 0;
    43. }

    3 4 5 信号都被屏蔽了，处理信号的过程发送信号只会先保存  

    当操作系统处理信号调用自定义动作时先将对应信号pend置为0，为了防止信号的嵌套处理，还会自动将当前信号屏蔽。

    sa_mask可以自己设置要屏蔽的信号

    信号发送

    什么是信号发送

    信号是由OS向进程发送的，信号就一定保存在进程中。普通信号有31个，以位图的形式储存到进程PCB的一个int类型中。实时信号与普通信号的区别就是：实时信号收到后必须立即处理不会等待，实时信号是存储在进程的一个队列中。所以发信号就是操作系统修改对应的int值或者队列

    信号发送方式

    键盘组合键

    例如：

    ctrl+c，信号2中断进程

    ctrl+\，信号3退出进程

    键盘组合键是怎么发出信号的呢？

    原理 

    键盘写入完毕后，会向CPU发送硬件中断包括中断号，CPU告诉操作系统，操作系统通过中断号到中断向量表寻找中断号所对应的方法地址，使用该方法将键盘缓冲区的数据写到OS缓冲区，操作系统拿到数据后对进程发出信号 

    另外，键盘只能向前台进程（哪个进程能获取键盘输入，哪个进程就是前台进程）发送信号。Linux中一个登录只能有一个前台进程，可以有多个后台进程。

    当我们./运行一个程序时，前台进程就是正在运行的程序，ctrl+c就会终止当前进程。

    如果在运行时./后面加上&，当前进程就会以后台进程的方式运行，ctrl+c无效。因为前台进程是bash，此时键盘任何输入都会给bash，也就意味着这时可以使用命令行

    kill命令

    kill signum PID

    系统调用接口

    kill 

    向其他进程发送信号

    样例：

    写一个可以给其他进程发信号的程序

    1. //myprocess.cc
    2. #include 
    3. #include 
    4. #include 
    5. using namespace std;
    6. int main()
    7. {
    8.     while(1)
    9.     {
    10.         cout << "process: " << getpid() << " running" << endl;
    11.         sleep(1);
    12.     }
    13.     return 0;
    14. }
    15.  
    16. //mykill.cc
    17. #include 
    18. #include 
    19. #include 
    20.  
    21.  
    22. using namespace std;
    23. void Usage(const char* argv)
    24. {
    25.     cout << argv << " pid " << "sig" << endl;
    26. }
    27.  
    28. int main(int argc, const char* argv[])
    29. {
    30.     if(argc != 3)
    31.     {
    32.         Usage(argv[0]);
    33.     }
    34.     else{
    35.         int n = kill(stoi(argv[1]), stoi(argv[2]));
    36.         if(n == -1)
    37.         {
    38.             perror("kill fail");
    39.             return -1;
    40.         }
    41.     }
    42.     return 0;
    43. }

    raise

    向当前进程发送信号

    实际上调用了kill接口，相当于kill(getpid(), sig)

    abort

    让当前进程终止

    实际上调用了kill接口，相当于kill(getpid(), 6)

    注意：信号6是由其他进程发来的，不会让进程退出

    alarm

    在设定时间过后，发送信号

    返回前一个定时器的剩余时间（以秒为单位），如果之前没有设置定时器，则返回0

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6. void fun(int sig)
    7. {
    8.     int n = alarm(5);
    9.     cout << "get alarm" << "time:" << n <
    10. }
    11.  
    12. int main()
    13. {
    14.     //alarm收到信号后默认退出进程，进行自定义信号捕捉
    15.     signal(SIGALRM, fun);
    16.     alarm(5);
    17.     while(1)
    18.     {
    19.         cout << "process running" << endl;
    20.         sleep(1);
    21.     }
    22. }

    异常

    例如遇到除0错误时，CPU在运算的过程中出现错误，会将这个情况告诉操作系统，再由操作系统给进程发信号，中断进程。操作系统即是硬件设备的管理者也是进程的管理者

    如果将这个信号自定义捕捉，并且捕捉的动作不会让进程退出，会怎么样呢？

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7. void fun(int signum)
    8. {
    9.     cout << "get signum" << signum << endl;
    10.     sleep(1);
    11. }
    12.  
    13. int main()
    14. {
    15.     signal(8,fun);
    16.     int a= 1/0;
    17.     return 0;
    18. }

    操作系统会一直给进程发信号。因为进程收到信号未关闭，进程会一直被CPU调度运行，一直出现错误。

    信号保存

    信号有几种状态：

    递达(delivery):实际执行信号的处理动作

    未决(panding):从信号被发出到递达之间的状态

    阻塞(block):进程可以阻塞某个信号，当该信号别发出时，不会递达，只有当信号解除阻塞时才会递达

    阻塞和忽略不同，忽略是递达后的处理方式

    信号保存主要就是通过阻塞实现的

    信号在内核中的表示：

    block位图表示信号是否被阻塞，pending位图表示信号是否发出，handler是函数指针数组，存储了信号的处理方法，SIG_DFL是默认方法,SIG_IGN是忽略,还可以指向用户区自己定义的方法。

    操作系统提供了block(阻塞信号集/信号屏蔽字)和pending(未决信号集)的数据类型sigset_t还有相应的系统调用接口

    信号集操作接口

    sigemptyset将所有标志位都置为0，sigfillset将所有标志位都置为1

    sigaddset/sigdelset ：增加/删除signum信号所对应的位置

    sigismember检测signum在set中是否为1

    修改屏蔽信号字接口

    how可以以下有几个值：

    SIG_BLOCK:set中包含了希望添加到当前屏蔽信号字的信号

    SIG_UNBLOCK:set包含了希望从当前屏蔽信号字删除的信号

    SIG_SETMASK:将屏蔽信号字设置为set

    set就是用来更改信号屏蔽字的屏蔽字参数，oset用来存储更改信号屏蔽字之前的屏蔽字参数

    显示未决信号集的接口

    将未决信号集拷贝到set

    实例

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. void hander(int sig)
    8. {
    9.     cout << "get signal:" << sig << endl;
    10. }
    11.  
    12. int main()
    13. {
    14.     signal(2,hander);
    15.     sigset_t set, oset;
    16.     sigemptyset(&set);
    17.     sigemptyset(&oset);
    18.     sigaddset(&set, SIGINT);
    19.     //设置屏蔽信号字
    20.     sigprocmask(SIG_BLOCK, &set, &oset);
    21.         
    22.     int cnt = 5;
    23.     while (1)
    24.     {
    25.         sigset_t pending;
    26.         sigpending(&pending);
    27.         //展示未决信号集
    28.         for (int i = 31; i >= 1; i--)
    29.         {
    30.             if (sigismember(&pending, i))
    31.                 cout << "1";
    32.             else
    33.                 cout << "0";
    34.         }
    35.         cout << endl;
    36.         sleep(3);
    37.  
    38.         cnt--;
    39.         if(cnt == 0)//解除屏蔽信号字
    40.         {
    41.             sigprocmask(SIG_SETMASK, &oset, nullptr);
    42.         }
    43.     }
    44.  
    45.     return 0;
    46. }

     注意，和信号捕捉一样，信号9和信号19不可以被阻塞

    信号处理

    什么时候处理

    结论：当进程从内核态变为用户态，操作系统会进行信号的检测和处理。

    内核态:进程访问操作系统的代码和数据

    用户态:进程访问自己的代码和数据

    CPU中有一些寄存器的标志位可以区分进程在哪个态。有几个进程就有几个用户级页表，而内核级页表只有一个，不管进程怎么切换，每个进程看到的内核空间都是一样的。从进程的角度看，调用系统调用接口，就是在自己的进程地址空间调用。从操作系统的角度看，在任意时刻，只要有进程运行就可以随时调用系统调用接口。

    怎么处理

    当进程进入内核态(例如调用了系统调用接口)，在执行系统调用操作后，会检查是否有可以递送的信号并进行处理然后返回用户态，如果是处理自定义的动作信号，就会先从内核进入用户态(因为用户态下，处理函数做非法操作会被操作系统拦截，保证了安全性)，调用信号处理函数，再回到内核态，最后返回用户态，从主控制流程上次中断的地方继续执行

    信号与进程等待

    子进程退出会向父进程发送信号SIGCHLD，不过这个信号默认处理方式时忽略的，可以通过自定义捕捉对进程回收。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. using namespace std;
    9. void header(int sig)
    10. {
    11.     pid_t rid;
    12.     while((rid = waitpid(-1,nullptr,WNOHANG)) > 0)
    13.     {
    14.         cout << "wait :" << rid << " success" << endl;
    15.     }
    16. }
    17.  
    18. int main()
    19. {
    20.     srand(time(nullptr));
    21.     signal(SIGCHLD, header);
    22.     // 创建10个子进程
    23.     for (int i = 10; i > 0; i--)
    24.     {
    25.         pid_t id = fork();
    26.         if (id == 0)
    27.         {
    28.             cout << "I am child:" << getpid() << endl;
    29.             sleep(rand() % 2 + 1);
    30.             cout << "child quit:" << getpid() << endl;
    31.             sleep(rand() % 2 + 1);
    32.             exit(0);
    33.         }
    34.         sleep(rand() % 3 + 3);
    35.     }
    36.  
    37.     while(1)
    38.     {
    39.         cout << "I am father:" << getpid() << endl;
    40.         sleep(1);
    41.     }
    42. }

    事实上,由于UNIX 的历史原因,要想不产生僵尸进程还有另外一种办法:父进程调 用sigaction将SIGCHLD的处理动作 置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。系统默认的忽 略动作和用户用sigaction函数自定义的忽略 通常是没有区别的,但这是一个特例。此方法对于Linux可用,但不保证 在其它UNIX系统上都可 用。请编写程序验证这样做不会产生僵尸进程。

  • 相关阅读:
    高效率开发APP中的常见问题
    【char类型转换】
    PowerBuilder连接SQLITE3
    【Hive】MapReduce 如何实现 Hive SQL 的基本操作-count
    模型微调迁移学习Finetune方法大全
    SpringBoot学习笔记（七）——邮件发送与SpringBoot其他框架
    设计模式之工厂模式（学习笔记）
    11-Java中常用的API
    AI搜索，围攻百度
    Win11C盘变红怎么办？Win11C盘变红的清理方法
  • 原文地址：https://blog.csdn.net/weixin_74269833/article/details/139497848