当前位置：首页 > news >正文

进程与信号

news 来源：原创 2025/9/19 4:33:25

前言

接触计算机的时候我们就接触过信号。比如说当我们进程卡死的时候，windows系统会跳出来一个弹窗告诉我们是否等待进程响应，如果关闭进程那么系统就会发信号给进程然后终止掉它。再比如我们打开任务管理器的时候，想要关闭进程那也是在发送信号给进程。Linux中我们能用kill命令通过进程的PID向进程发送信号。

那么进程是如何接收信号，又是如何处理他们的呢？能不能修改接收信号后的行为呢？这些都是本篇博客的内容。

一、基本介绍

软中断信号（signal，简称为信号）用来通知进程发生了异步事件。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。注意，信号只是用来通知某进程发生了什么事件，并不给该进程传递任何数据。

收到信号的进程对各种信号有不同的处理方法。处理方法可以分为三类：

第一种是类似中断的处理程序，对于需要处理的信号，进程可以指定处理函数，由该函数来处理。

第二种方法是，忽略某个信号，对该信号不做任何处理，就象未发生过一样。

第三种方法是，对该信号的处理保留系统的默认值，对大部分的信号的缺省操作是使得进程终止。此方法为缺省操作。进程通过系统调用signal来指定进程对某个信号的处理行为。

在进程表的表项中有一个软中断信号域，该域中每一位对应一个信号，当有信号发送给进程时，对应其位置位。由此可以看出，进程对不同的信号可以同时保留，但对于同一个信号，进程并不知道在处理之前来过多少个。

二、信号种类

在Linux系统中。信号的种类我们能够通过kill -l的方式查看所有信号，总计64种，其中前32种比较常用：

图2-1 信号种类

常用的信号有“SIGINT”2号这个是我们按“ctrl+c”后发送的，还有“ctrl+\”是“SIGQUIT”3号。

比较特殊的信号有“9号”信号“SIGKILL”和“19号”信号“SIGSTOP”。在系统中，收到这两个信号之后的操作是默认的、无法改变的。分别会杀掉进程和暂停进程。之前我们在shell中按下“ctrl+z”就会发送19号信号给进程，然后界面就不动了，这是因为进程被暂停住了。

比如现在我们启动一个进程，然后我们按下ctrl+z就可以在后台暂停它。然后我们可以按下“jobs”我们可以查看到进程状态：

图2-2 暂停进程

现在我们可以看到状态是stop了，然后我们让他恢复运行可以使用“bg + 任务号”或者“fg + 任务号”，前者会在后台运行另一个则是在前台运行。

图2-3 进程前后台移动

在前台运行的时候我们才能通过键盘输入向前台进程发送信号，后台进程是接收不到键盘信号的。这里从上图的中间行可以看出，后台运行的时候我们的命令行也能运行，并且“ctrl+c”的信号接收不到。当我们把任务调回前台，就能够正常获取信号了。

如果想查看信号背后的执行逻辑能够通过“man 7 signal”查看。

图组2-4 查看signal信号的默认行为

三、信号相关操作

1. 修改获得信号后的行为

sighandler_t signal(int __sig, sighandler_t __handler)

通过上述函数能够修改获得信号后的操作，其中__sig表示信号，__handler其实是void *（int）类型的指针传递的是执行函数的地址。

如果我们要修改2号信号后进程的操作，我们可以使用以下代码验证：

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>void handlerSig(int sig)
{std::cout << "获得了一个信号：" << sig << std::endl;exit(sig);
}int main()
{// for(int i = 1; i < 32; i++)//     signal(i, handlerSig);signal(SIGINT, handlerSig);int cnt = 0;for(; cnt < 100; cnt++){std::cout << "hello world:" << cnt << std::endl;sleep(1); }return 0;
}

图3-1 修改信号2操作后执行的结果

从图中可以看出，我们在收到信号2的时候还打印了一句话。

2. 发送信号的方式

之前我们能够通过kill命令发送信号给对应PID的进程，除此之外还有其他方法吗？有的有的我们可以在系统中通过系统函数向对应的进程发送信号。

int kill(pid_t pid, int sig);

这个函数就能向对应的pid发送sig信号。

我们可以把这个函数封装成命令行格式：

#include <iostream>
#include <sys/types.h>
#include <string>
#include <signal.h>// ./mkill signumber pid
int main(int argc, char* argv[])
{if(argc != 3){std::cout << "./mykill signumber pid\n";return 1;}int signum = std::stoi(argv[1]);pid_t target = std::stoi(argv[2]);int n = kill(target, signum);if(n == 0){std::cout << "send" << signum << " to " << target << std::endl;}return 0;
}

如此一来用“./mykill + 信号 + PID”就能让对应的进程获得信号这里不在演示。使用方式和kill很像。如果不记得命令行怎么从shell到进程里来，可以查看往期博客。链接如下：

Linux环境变量和命令行参数_linux脚本获取输入参数命令-CSDN博客文章浏览阅读582次，点赞14次，收藏15次。最近学到了关于环境变量和命令行参数的相关内容，为了以后方便复习，所以整理一下讲讲看。内容挺多的，除了单独的意义之外，还包括如何获得这些参数。这里尽可能用简单的话概括了。_linux脚本获取输入参数命令https://blog.csdn.net/2302_81342533/article/details/144158919

除了给其他进程发送信号，也可以给自己的进程发送信号。

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

感觉就是封装了kill的接口，把pid直接从自己的getpid（）中获取了，于是只用发送信号sig了。

我们可以通过以下函数来查看我们raise的使用。

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>// void sigint_handler(int signum) {
//     printf("Received SIGINT signal:%d\n", signum);
//     exit(0);
// }// int main() {
//     struct sigaction act;
//     act.sa_handler = sigint_handler;
//     sigemptyset(&act.sa_mask);
//     act.sa_flags = 0;//     if (sigaction(SIGINT, &act, NULL) < 0) {
//         perror("sigaction");
//         exit(1);
//     }//     while (1) {
//         printf("Waiting for SIGINT signal...\n");
//         sleep(1);
//     }//     return 0;
// }void handlerSig(int sig)
{std::cout << "获得了一个信号：" << sig << std::endl;// exit(sig);
}int main()
{for(int i = 1; i < 32; i++)signal(i, handlerSig);// signal(SIGINT, handlerSig);for(int i = 1; i < 32; i++){sleep(1);if(i == 9 || i == 19){continue;}raise(i);}int cnt = 0;for(; cnt < 100; cnt++){std::cout << "hello world:" << cnt << std::endl;sleep(1);}return 0;
}

这里我们跳过了9号和19号信号的发送，其他信号全部自定义。

图3-2 给进程自己发信号

这样我们就能够自己发信号了，如果发送9信号进程就会终止。这也是无法修改的，我们可以通过删除for循环中的if语句来观察进程的行为——被killed。

3.信号中的默认行为

如图2-4所示，这里我们能够看到行为这一栏，有“Core”、“Term”、 “Ign”三种，前两种都会终止进程，第三种啥都不干。但是“Core”这一栏我们如果开启了系统中coredump功能，就会生成一个core文件。这个文件能够使用gdb打开调试，查看调试信息，进程错误在哪。

系统中的功能我们能够通过ulimit进行查看和修改。

图3-3 ulimit

如图3-3，这里-c那一栏就是我们的coredump功能的位置，将0修改为其他数便能启动。另一方面之前我们在创建子进程的时候会回收子进程内容。有个status的返回值，这个值里的coredump第8位就是表示这个功能有没有开启。

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <functional>
#include <vector>
#include <sys/wait.h>int main()
{pid_t id = fork();if(id == 0){sleep(2);int a = 10;a /= 0;}else{int status = 0;waitpid(id, &status, 0);printf("signal: %d, exit code: %d, core dump: %d\n",(status & 0x7F), (status >> 8) & 0xFF, (status >> 7) & 1);}return 0;
}

运行这个程序就能看到coredump功能是否开启：

图3-4 子进程返回值的查看

4.其他

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

还有一些函数例如alarm能够给进程在设定的秒数后发送SIGALRM信号。sigaction函数也能修改进程获得信号后处理信号的方式。这里不在详谈。

四、系统处理信号的方式

首先我们知道操作系统能将信号发给进程，那么进程又是怎么知道的呢？答案是我们在启动进程后会形成一个task_struck的结构体，这个结构体我们进程在执行的时候会在时间片用完或者出异常的时候回来看一眼。这个结构体里有描述信号获得关系的位图，然后进程自己就知道有没有信号了。

从大的方向来说，信号传递的过程分为三步：

信号产生--->信号保存--->信号处理-----

直到处理完成我们将其称为信号抵达。

从进程上查看这个过程，将如图4-1所示：

图4-1 进程对信号的处理

如图，分为5步。

（1）因为指令、异常、系统调用进入内核。

（2）内核下处理完异常或系统调用返回用户模式前查看信号。

（3）如果有自定义函数就返回用户模式执行自定义函数，否则在内核中执行默认行为。

（4）执行完自定义后返回内核，继续第三步。

（5）信号完成后返回用户模式，接着原来的位置向下执行。

五、信号的保存

实际执行信号的处理动作称为信号递达（Delivery）。

信号从产生到递达之间的状态称为信号未决（Pending）。

进程可以阻塞（Block）某个信号，被阻塞的信号在Pending中，只有不阻塞才能递达。还有一种之前所说的忽略，那是接收到信号之后默认动作就是啥都不干。

这些信号被记录在task_struct的结构体中：

图5-1 信号储存

之前描述的信号函数signal，就是用来修改hander表中的指针的。除了能修改hander之外，我们还能通过系统调用修改block。于是我们需要认识以下内容。

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;
typedef __sigset_t sigset_t;#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signum);
int sigdelset(sigset_t *set, int signum);
int sigismember(const sigset_t *set, int signum);

这些函数都是用来修改sigset_t类型的，这个类型其实是一个包含一个数组的结构体，转义理解就向图5-1所示的样子。

这些函数的作用分别是全部置为0、全部置为1、将某个信号置为1、将某个信号置为0，查找信号位置的值。

当我们了解了这些还不够，我们需要通过这些修改系统中task_struct中的内容，这就用到了函数：

// 能够修改进程中black中的数据
int sigprocmask(int __how, const sigset_t *__restrict__ __set, sigset_t *__restrict__ __oset)
//                 方法3种                  用于替换的目标                  输出旧的black
//          比如SIG_SETMASK是直接替换//获取对应的pending，和black相对应，如果对应的位上为1那么就表示接收到了
int sigpending(sigset_t *__set)
//                      获取的set

为了加深我们对函数的理解，我准备了以下代码：先对信号2进行屏蔽，然后一直打印pending直到5秒后解除屏蔽。期间我会给进程发送信号2，我们应该能看到pending表中2号信号的位置显示1。然后5秒后不在阻塞后进程退出。

图5-2 屏蔽信号2后pending结果

根据图5-2，这说明我们屏蔽成功了，我们可以依照此法屏蔽其他信号。当然9号信号和19号信号的屏蔽仍然是特殊处理的，不会被屏蔽。

六、其他

关于信号还有一些比较杂的知识，全都放这里讲：

比如子进程退出会发送13号信号SIGCHLD给父进程。

子进程给父进程的返回值后7位表示子进程异常退出时获得的信号，第8位表示是否执行coredump。coredump就是gdb的调试文件，能够快速定位进程出错的位置。

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         sleep(2);
//         int a = 10;
//         a /= 0;
//     }
//     else
//     {
//         int status = 0;
//         waitpid(id, &status, 0);
//         printf("signal: %d, exit code: %d, core dump: %d\n",
//                 (status & 0x7F), (status >> 8) & 0xFF, (status >> 7) & 1);
//     }//     return 0;
// }

假如代码如上所示signal就会是子进程发生除0错误后获得的信号。而coredump默认为0。如果我们想开启系统中coredump功能，我们需要使用ulimit进行修改系统中的内容，打开coredump功能。

前言