【Linux学习】进程信号2-阿里云开发者社区

【Linux学习】进程信号1：https://developer.aliyun.com/article/1383947

我们发现最终打印的结果是1秒cnt++了98721次，但是真的是只++了这么多次吗？肯定不止，因为这里的打印属于IO操作，相比于CPU的速度简直是天差地别。所以让我们改写一下程序：

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;
int cnt = 0;
void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << " cnt = "<< cnt << endl;
}
int main()
{
    signal(SIGALRM, handler);
    alarm(1); //设置1s
    while (true)
    {
        cnt++;
        //printf("cnt = %d\n", cnt);
    }
    return 0;
}

结果如下：

这才是cnt++执行1s的次数，其中该进程收到的14号信号就是SIGALRM信号。由此也证明了计算机的CPU速度与外设进行IO时的速度相比是非常快的。

4. 由硬件异常产生信号

程序崩溃的本质：

当我们的程序中存在除0、越界或者野指针时引起程序崩溃，其本质就是因为进程收到了来自操作系统的异常信号。那么操作系统为什么知道这些异常的呢？

原因是CPU当中有许多的寄存器，当对两个数进行算术运算时，操作系统先将这两个操作数分别放到两个寄存器当中，然后进行运算并把结果写回寄存器当中。此外，CPU当中还有一组寄存器叫做状态寄存器，它可以用来标记当前指令执行结果的各种状态信息，如有无进位、有无溢出等等。而操作系统是软硬件资源的管理者，在程序运行过程中，若操作系统发现CPU内的某个状态标志位被置位，而这次置位就是因为出现了某种除0错误而导致的，那么此时操作系统就会马上识别到当前是哪个进程导致的该错误，并将所识别到的硬件错误包装成信号发送给目标进程。

用以下代码模拟野指针异常：

#include <iostream>
#include <signal.h>
using namespace std;
int cnt = 0;
void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << endl;
}
int main()
{
    signal(SIGSEGV, handler);
    sleep(1);
    int *p = nullptr;
    *p = 1000;
    while (true);
    return 0;
}

结果该进程收到了11号信号，也就是SIGSEGV信号。

首先我们必须知道的是，当我们要访问一个变量时，一定要先经过页表的映射，将虚拟地址转换成物理地址，然后才能进行相应的访问操作。其中页表属于一种软件映射关系，而实际上在从虚拟地址到物理地址映射的时候还有一个硬件叫做MMU，它是一种负责处理CPU的内存访问请求的计算机硬件，因此映射工作不是由CPU做的，而是由MMU做的，但现在MMU已经集成到CPU当中了。

当需要进行虚拟地址到物理地址的映射时，我们先将虚拟地址导给MMU，然后MMU会计算出对应的物理地址，我们再通过这个物理地址进行相应的访问。

而MMU既然是硬件单元，那么它当然也有相应的状态信息，当我们要访问不属于我们的虚拟地址时，MMU在进行虚拟地址到物理地址的转换时就会出现错误，然后将对应的错误写入到自己的状态信息当中，这时硬件上面的信息也会立马被操作系统识别到，进而将对应进程发送SIGSEGV信号。

三、信号阻塞

1. 信号阻塞即其他相关概念

实际执行信号的处理动作称为信号递达（Delivery）。
信号从产生到递达之间的状态称为信号未决（Pending）。
进程可以选择阻塞（Block）某个信号。
被阻塞的信号产生时将保持在未决状态，直到解除对信号的阻塞，才会执行递达动作。
注意，信号阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是信号递达后可选的一种处理方式。

2. 信号在内核中的表示

信号在内核中的表示示意图：

在block位图中，比特位的位置代表某一个信号，其内容表示该信号是否被阻塞。
在pending位图中，比特位的位置代表某一个信号，其内容表示是否收到该信号。
handler表本质上是一个函数指针数组，数组的下标代表一个信号，数组的内容表示该信号递达时的处理动作，包括默认、忽略和自定义。
block、pending和handler这三张表是一一对应的。

【说明】

每个信号都有两个标志位，分别表示阻塞（Block）和未决（Pending），还有一个函数指针表示对信号的处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。如上图所示。
SIGINT信号以及产生，但是正处于阻塞状态，所以暂时不能被递达。虽然它的处理动作是忽略，但是没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除该阻塞。
SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。

【注意】

如果在进程解除对某信号的阻塞之前，这种信号产生过多次：POSIX.1允许系统递送该信号一次或多次。但是Linux是这样实现的:常规信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里。

3. sigset_t

从信号在内核中的示意图来看，每个信号只有一个比特位的未决标志，非0即1，不记录该信号产生了多少次，阻塞标志也是这样表示的。

因此，未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t的定义如下：

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
  unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;
typedef __sigset_t sigset_t;

sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态:

在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞。
而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

其中阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里的“屏蔽”应该理解为阻塞而不是忽略。

4. 信号集操作函数

sigset_t类型对于每种信号用一个比特位表示“有效”或“无效”状态，至于这个类型内部如何存储这些bit则依赖于系统实现，从使用者的角度是不必关心的，使用者只能调用以下函数来操作sigset_ t变量，而不应该对它的内部数据做任何解释，比如用printf直接打印sigset_t变量是没有意义的。

信号集操作函数：

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember（const sigset_t *set, int signo);

【函数说明】

函数sigemptyset初始化set所指向的信号集，使其中所有信号的对应比特位清零，表示该信号集不包含任何有效信号。
函数sigfillset初始化set所指向的信号集，使其中所有信号的对应比特位置位，表示该信号集的有效信号包括系统支持的所有信号。
注意，在使用sigset_ t类型的变量之前,一定要调用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。
初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。
前面四个函数都是调用成功返回0，出错返回-1。sigismember是一个布尔函数，用于判断一个信号集的有效信号中是否包含某种信号，若包含则返回1，不包含则返回0，出错返回-1。

5. sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

【函数原型】

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

【返回值】

调用成功返回0，失败则返回-1。

【参数说明】

若oset是非空指针，则读取进程当前信号屏蔽字，并提供oset参数传出；
如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改；
如果oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。
假设当前的信号屏蔽字为mask，下表说明了how参数的可选值及其含义：

【注意】：如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask返回前，至少将其中一个信号递达。

6. sigpending

sigpending函数的作用是读取当前进程的未决信号集，通过set参数传出。

【函数原型】

int sigpending(sigset_t *set);

【返回值】调用成功返回0，否则返回-1。

下面用刚学的几个函数做个实验。程序如下:

#include <iostream>
#include <signal.h>
#include <unistd.h>
using namespace std;
void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号: " << signo << endl;
    // exit(1);
}
static void showPendings(sigset_t *pendings)
{
    for (int sig = 1; sig <= 31; ++sig)
    {
        if (sigismember(pendings, sig))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << endl;
}
int main()
{
    cout << "pid = " << getpid() << endl;
    // 3. 屏蔽2号信号
    sigset_t bsig, obsig;
    sigemptyset(&bsig);
    sigemptyset(&obsig);
    // 3.1 添加2号信号到信号屏蔽字中
    sigaddset(&bsig, 2);
    // 2. signal
    signal(sig, handler);
    // 3.2 设置用户集的信号屏蔽字到内核中，让当前进程屏蔽掉2号信号
    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 打印当前pending信号集的内容
            showPendings(&pendings);
        }
        sleep(1);
        cnt++;
        if (cnt == 20)
        {
            cout << "解除对所有信号的block..." << endl;
            sigset_t sigs;
            sigemptyset(&sigs);
            sigaddset(&sigs, 2);
            sigprocmask(SIG_UNBLOCK, &sigs, nullptr);
        }
    }
    return 0;
}

该程序的功能是先用上述的函数将2号信号进行屏蔽（阻塞），使用kill命令或组合按键向进程发送2号信号。此时2号信号会一直被阻塞，并一直处于pending（未决）状态。使用sigpending函数获取当前进程的pending信号集进行验证。20秒后，解除对2号信号的屏蔽。

执行结果如下：

第一次发送2号信号，我们可以发现signal函数没有收到2号信号，而pending表中存在2号信号，0秒后，解除对2号信号的屏蔽，signal函数就接收到了2号信号。

这里我们可以发现，在解除2号信号之后，2号信号的自定义动作的打印是在打印全为0的pending表之前执行的。这是因为如果调用sigprocmask解除对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达。

四、信号捕捉

在认识信号捕捉之前，首先得认识内核和用户之间的连续和区别。

1. 内核态和用户态

用户态和内核态是操作系统的两种运行状态。

内核态：处于内核态的 CPU 可以访问任意的数据，包括外围设备，比如网卡、硬盘等，处于内核态的 CPU 可以从一个程序切换到另外一个程序，并且占用 CPU 不会发生抢占情况，一般处于特权级 0 的状态我们称之为内核态。
用户态：处于用户态的 CPU 只能受限的访问内存，并且不允许访问外围设备，用户态下的 CPU 不允许独占，也就是说 CPU 能够被其他程序获取。

进程收到信号之后，并不是立即处理信号，而是在从内核态切换回用户态的时候，进行对信号的检查与处理。

操作系统在内核态与用户态之间切换的情况：

从用户态切换为内核态通常有如下几种情况：

进行系统调用时
当前进程的时间片结束，导致进程切换
产生异常、中断、陷阱等

从内核态切换为用户态有如下几种情况：

系统调用返回时
进程切换完毕
异常、中断、陷阱等处理完毕

此外，由用户态切换为内核态我们称之为陷入内核。每当我们需要陷入内核的时，本质上是因为我们需要执行操作系统的代码，比如系统调用函数是由操作系统实现的，我们要进行系统调用就必须先由用户态切换为内核态。

2. 内核空间和用户空间

我们都知道每一个进程都有属于自己的进程地址空间，该空间其实是有内核空间和用户空间组成的。其中用户实现的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系；而内核空间是只操作系统的代码和数据，通过内核级页表与物理内存之间建立映射关系。

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，由所有进程所共同拥有。只是唯一区别在于该进程是否有权利去访问内核空间。

3. 内核实现信号捕捉

信号捕捉示意图：

当执行主控制流程的时候，可能因为某些情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。在查看pending位图时，如果发现有未决信号，并且该信号没有被阻塞，那么此时就需要该信号进行处理。如果待处理信号的处理动作是默认或者忽略，则执行该信号的处理动作后清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可。

但如果待处理信号是自定义捕捉的，即该信号的处理动作是由用户提供的，那么处理该信号时就需要先返回用户态执行对应的自定义处理动作，执行完后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，继续执行主控制流程的代码。

4. sigaction函数

捕捉信号除了用前面用过的signal函数之外，我们还可以使用sigaction函数对信号进行捕捉。

【函数原型】

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

sigaction函数可以读取和修改与指定信号相关联的处理动作，该函数调用成功返回0，出错返回-1。

【参数说明】

signum代表指定信号的编号。
若act指针非空，则根据act修改该信号的处理动作。
若oldact指针非空，则通过oldact传出该信号原来的处理动作。
参数act和oldact都是结构体指针变量，该结构体的定义如下：

struct sigaction
  {
    /* Signal handler.  */
#ifdef __USE_POSIX199309
    union
      {
  /* Used if SA_SIGINFO is not set.  */
  __sighandler_t sa_handler;
  /* Used if SA_SIGINFO is set.  */
  void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;
# define sa_handler __sigaction_handler.sa_handler
# define sa_sigaction __sigaction_handler.sa_sigaction
#else
    __sighandler_t sa_handler;
#endif
    /* Additional set of signals to be blocked.  */
    __sigset_t sa_mask;
    /* Special flags.  */
    int sa_flags;
    /* Restore handler.  */
    void (*sa_restorer) (void);
  };

结构体的第一个成员sa_handler：

将sa_handler赋值为常数SIG_IGN传给sigaction函数，表示忽略信号。
将sa_handler赋值为常数SIG_DFL传给sigaction函数，表示执行系统默认动作。
将sa_handler赋值为一个函数指针，表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数。

注意：所注册的信号处理函数的返回值为void，参数为int，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。显然这是一个回调函数，不是被main函数调用，而是被系统所调用。

结构体的第二个成员sa_sigaction：

sa_sigaction是实时信号的处理函数。

结构体的第三个成员sa_mask：

如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时，自动恢复原来的信号屏蔽字。

例如，下面我们用sigaction函数对2号信号进行了捕捉，将2号信号的处理动作改为了自定义的打印动作，并在执行一次自定义动作后将2号信号的处理动作恢复为原来默认的处理动作。

struct sigaction act, oact;
void handler(int signo)
{
    printf("get a signal:%d\n", signo);
    sigaction(2, &oact, NULL);
}
int main()
{
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(2, &act, &oact);
    while (1)
    {
        cout << "main running" << endl;
        sleep(1);
    }
    return 0;
}

由运行结果可以发现，第一次向进程发送2号信号，执行的是自定义动作，然后再次发送2号信号，则执行默认动作。

五、可重入函数

要理解可重入函数，可以通过链表的插入过程来进行理解。

如图，main函数调用insert向链表中插入一个节点node1，但是代表执行的1的位置时，该进程收到了一个信号，该信号的处理动作是再向链表插入一个节点node2，处理完该信号后又返回4的位置继续执行插入node1的动作。现在则发生了下面的情况：

我们可以发现最终node1和node2指向了同一个节点，但是只有node1真正的插入了链表，而node2却丢失了，造成内存泄漏。

在该例中，main函数和sighandler函数使用不同的堆栈空间，它们之间不存在调用与被调用的关系，是两个独立的控制流程，因此insert函数被不同的控制流调用，造成了第一次调用还没有返回时就再次调用了该函数，这种现象称之为可重入现象。

然而insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数我们称之为不可重入函数，反之，如果一个函数只访问自己的局部变量或参数，则称之为可重入（Reentrant）函数。

如果一个函数符合以下条件之一则是不可重入的:

调用了malloc或free，因为malloc也是用全局链表来管理堆的。
调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

六、重识 volatile 关键字

volatile是C语言的一个关键字，该关键字的作用是保持内存的可见性。告知编译器，被该关键字修饰的变量，不允许被优化，对该变量

的任何操作，都必须在真实的内存中进行操作。

例如，下面的代码实现了对2号信号的捕捉，当收到2号信号时，将全局变量flag由0变为1，观察程序是否能正常退出。

首先不使用volatile关键字修饰flags:

#include <stdio.h>
#include <signal.h>
// 保持内存的可见性
int flags = 0;
void handler(int signo)
{
    flags = 1;
    printf("更改flags: 0->1\n");
}
int main()
{
    signal(2, handler);
    while (!flags);
    printf("进程是正常退出的!\n");
    return 0;
}

执行结果：

该程序的运行过程好像都在我们的意料之中，但实际并非如此。代码中的main函数和handler函数是两个独立的执行流，而while循环是在main函数当中的，在编译器编译时只能检测到在main函数中对flag变量的使用。

此时编译器检测到在main函数中并没有对flag变量做修改操作，在编译器优化级别较高的时候，就有可能将flag设置进寄存器里面。

此时main函数在检测flag时只检测寄存器里面的值，而handler执行流只是将内存中flag的值置为1了，那么此时就算进程收到2号信号也不会跳出死循环。

在编译代码时携带-03选项使得编译器的优化级别最高，此时再运行该代码。

此时再向进程发生2号信号，该进程也不会终止。

若在flag变量前面加上volatile修饰，则进程就可以进程退出了。

七、SIGCHLD信号

在前面进程的学习过程中，我们知道了wait和waitpid函数清理僵尸进程，父进程可以阻塞等待子进程结束，也可以非阻塞地查询是否有子进

程结束等待清理(也就是轮询的方式)。但是采用第一种方式，父进程阻塞了就不能处理自己的工作了；采用第二种方式，父进程在处理自己的工作的同时还要记得时不时地轮询一下，程序实现复杂。

其实，子进程在终止时会给父进程发SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需专心处理自己的工作，不必关心子进程了，子进程在终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。

例如编写一个程序完成以下功能：

父进程调用fork函数创建出子进程，子进程调用exit(2)终止，父进程自定义SIGCHLD信号的处理函数，在其中调用wait函数获得子进程的退出状态并打印。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
void handler(int sig)
{
    pid_t id;
    while ((id = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("wait child success: %d\n", id);
    }
    printf("child is quit! %d\n", getpid());
}
int main()
{
    signal(SIGCHLD, handler);
    pid_t cid;
    if ((cid = fork()) == 0)
    { // child
        printf("child : %d\n", getpid());
        sleep(3);
        exit(1);
    }
    while (1)
    {
        printf("father proc is doing some thing!\n");
        sleep(1);
    }
    return 0;
}

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

测试代码如下：

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <signal.h>
#include <cassert>
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 < 3; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            //子进程
            int cnt = 3;
            // 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;
}

运行结果如下：

这样，父进程调用signal将SIGCHLD的处理动作置为SIG_IGN，fork出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程，父进程也可以做自己的工作并且不用管子进程，提高了程序的运行效率。

【Linux学习】进程信号2