Linux快速入门之 信号（13）

最新推荐文章于 2024-05-01 15:13:50 发布
最新推荐文章于 2024-05-01 15:13:50 发布
阅读量2.5k 收藏 9
点赞数 6
分类专栏： Linux 文章标签： linux unix 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49730048/article/details/123736807
版权

信号

文章目录

1.1 信号概述

Linux中的信号是一种信号机制，其本质是一个整数，不同的信号对应不同的值，由于信号的结构简单所以天生不能携带很多信息量；但是信号在系统中的优先级是非常高的；

在Linux系统中很多常规操作都会有相关信号产生，例如：

通过键盘操作产生信号：用户按下Ctril + C ，键盘输入产生了一个硬件中断，使用这个快捷键会产生信号，该信号会杀死对应进程；

通过shell命令产生信号 ： 通过kill命名终止某一个进程 ，kill -9 进程PID；

通过函数调用产生信号： 如果当前CPU正在执行这个进程的代码调用，例如sleep()函数，进程收到相关的信号，被迫挂起；

通过对硬件的非法访问产生信号： 正在运行的程序访问了非法内存，发送段错误，进程退出；

信号也可以实现进程间通信，但是传递的信息量很少，同时由于信号的优先级很高，其对应的处理动作是回调完成的，它会打乱程序原有的处理流程影响到最终的处理结果。因此不建议使用信号进行进程间通信；

1.1.1 信号编号

通过kill -l 命令可以查看系统定义的信号列表

liu@liu-Ubuntu:~$ kill -l
 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX

信号产生的时机和对应的默认处理动作：

编码信号对应事件默认动作
1SIGHUP用户退出 shell 时，由该 shell 启动的所有进程将收到这个信号终止进程
2SIGINT当用户按下了 <Ctrl+C> 组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号终止进程
3SIGQUIT用户按下 <ctrl+> 组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号终止进程
4SIGILLCPU 检测到某进程执行了非法指令终止进程并产生 core 文件
5SIGTRAP该信号由断点指令或其他 trap 指令产生终止进程并产生 core 文件
6SIGABRT调用 abort 函数时产生该信号终止进程并产生 core 文件
7SIGBUS非法访问内存地址，包括内存对齐出错终止进程并产生 core 文件
8SIGFPE在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为 0 等所有的算法错误终止进程并产生 core 文件
9SIGKILL无条件终止进程。本信号不能被忽略，处理和阻塞终止进程，可以杀死任何进程
10SIGUSE1用户定义的信号。即程序员可以在程序中定义并使用该信号终止进程
11SIGSEGV指示进程进行了无效内存访问 (段错误)终止进程并产生 core 文件
12SIGUSR2另外一个用户自定义信号，程序员可以在程序中定义并使用该信号终止进程
13SIGPIPEBroken pipe 向一个没有读端的管道写数据终止进程
14SIGALRM定时器超时，超时的时间 由系统调用 alarm 设置终止进程
15SIGTERM程序结束信号，与 SIGKILL 不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。执行 shell 命令 Kill 时，缺省产生这个信号终止进程
16SIGSTKFLTLinux 早期版本出现的信号，现仍保留向后兼容终止进程
17SIGCHLD子进程结束时，父进程会收到这个信号忽略这个信号
18SIGCONT如果进程已停止，则使其继续运行继续 / 忽略
19SIGSTOP停止进程的执行。信号不能被忽略，处理和阻塞为终止进程
20SIGTSTP停止终端交互进程的运行。按下 <ctrl+z> 组合键时发出这个信号暂停进程
21SIGTTIN后台进程读终端控制台暂停进程
22SIGTTOU该信号类似于 SIGTTIN，在后台进程要向终端输出数据时发生暂停进程
23SIGURG套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达忽略该信号
24SIGXCPU进程执行时间超过了分配给该进程的 CPU 时间 ，系统产生该信号并发送给该进程终止进程
25SIGXFSZ超过文件的最大长度设置终止进程
26SIGVTALRM虚拟时钟超时时产生该信号。类似于 SIGALRM，但是该信号只计算该进程占用 CPU 的使用时间终止进程
27SGIPROF类似于 SIGVTALRM，它不公包括该进程占用 CPU 时间还包括执行系统调用时间终止进程
28SIGWINCH窗口变化大小时发出忽略该信号
29SIGIO此信号向进程指示发出了一个异步 IO 事件忽略该信号
30SIGPWR关机终止进程
31SIGSYS无效的系统调用终止进程并产生 core 文件
34-64SIGRTMIN ～ SIGRTMAXLINUX 的实时信号，它们没有固定的含义（可以由用户自定义）终止进程
1.1.2 查看信号信息

通过Linux提供的man文档可以查看所有信号的详细信息

#查看 man文档的信号描述
$ man 7 signal

在信号描述中介绍了对产生的信号的五种默认处理动作，分别是：

  1. Term: 信号将进程终止
  2. Ign: 信号产生之后默认被忽略
  3. Core: 信号将进程终止，并且产生一个core文件（用于gdb调试）
  4. Stop： 信号会暂停进程的运行
  5. Cont: 信号会让暂停的进程继续运行

注意：

9号信号和19号信号不能被 捕捉、阻塞和忽略：

9号信号：无条件杀死进程；

19号信号： 无条件暂停进程；

1.1.3 信号的状态

Linux信号有三种状态，分别为：产生、未决、递达

  1. 产生： 键盘输入，函数调用、执行shell命令，对硬盘进行非法访问都会产生信号；
  2. 未决： 信号产生了但是还没有被处理掉，这个期间信号的状态称为未决状态；
  3. 递达： 信号被处理了（某个进程处理掉）

在这里插入图片描述

1.2 信号相关函数

Linux系统有很多函数能够产生信号，例如下面几个函数；

1.2.1 kill/raise/abort 函数

三个函数功能类似，可以发送相关信号给指定对应进程

  • kill 发送指定的信号给指定的进程
#include <signal.h>
# 给某个进程发送某个信号
int kill(pid_t pid ,int sig);

参数：

pid: 进程ID；

sig： 要发送的信号；

//自己杀死自己
kill(getpid(),9);
//子进程杀死父进程
kill(getppid(),10);
  • raise 给当前进程发送指定的信号
//给自己发送某个信号
#include <signal.h>
// 参数为给当前进程发送的信号
int raise(int sig);
  • abort: 给当前进程发送一个固定信号（SIGABRT）;
//中端函数 ，调用这个函数，发送一个固定信号杀死当前进程
#include <stdlib.h>
void abort(void);
1.2.2 定时器
  • alarm 函数

alarm() 函数只能进行单次定时，定时完成发射出一个信号。

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

参数： 倒计时 second 秒，倒计时完成发送一个信号 SIGALRM（中端当前进程）,当前进程收到这个信号；

返回值： 大于 0 为倒计时还剩多少秒 ； 返回值为0 表示倒计时完成信号被发出；

//使用定时器函数，检测当前计算机1s 内能数多少数
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>

int main()
{
    //设置一个1s的定时器 
    alarm(1);   //1s 后进程中断
    int i =0;
    while(1)
    {
        printf("%d \n",i++);
    }
    return 0;
}
  • setitimer 函数

setitimer() 函数可以进行周期性定时，每触发一次定时器就会发射出一个信号。

// 这个函数可以实现周期性定时, 每个一段固定的时间, 发出一个特定的定时器信号
#include <sys/time.h>

struct itimerval {
	struct timeval it_interval; /* 时间间隔 */
	struct timeval it_value;    /* 第一次触发定时器的时长 */
};
// 举例: luffy有一个闹钟, 并且使用这个闹钟定时:
// 早晨7点中起床, 第一次闹钟响起时可能起不来, 之后每隔5分钟再响一次
//  - it_value: 当前设置闹钟的时间点 到 明天早晨7点 对应的总秒数
//  - it_interval: 闹钟第一次响过之后, 每隔5分钟响一次

// 这个结构体表示的是一个时间段: tv_sec + tv_usec
struct timeval {
	time_t      tv_sec;         /* 秒 */
	suseconds_t tv_usec;        /* 微妙 */
};

int setitimer(int which, const struct itimerval *new_value, 
              struct itimerval *old_value);

参数:

  • ==which:==定时器使用什么样的计时法则，不同的计时法则发出的信号不同；
  • ​ ITIMER_REAL: 自然计时法 ，最常用，发出的信号为 SIGALRM, 一般使用这个宏值，自然计时法时间 = 用户区 + 内核 + 消耗的时间 (从进程的用户区到内核区切换使用的总时间)；
  • ​ ITIMER_VIRTUAL: 只计算程序在用户区运行使用的时间 ，发射的信号为 SIGVTALRM；
  • ​ ITIMER_PROF: 只计算内核运行使用的时间 ，发出的信号为 SIGPROF；
  • new_value: 给定时器设置的定时信息，传入参数；
  • old_value: 上一次给定时器设置的定时信息，传出参数，如果不需要这个信息，指定为 NULL；

1.3 信号集

1.3.1 阻塞 /未决信号集

阻塞/未决信号集是PCB中非常重要的信号集。 但是操作系统不允许我们直接对这两个信号集直接操作，而是需要自定义另外一个集合，借助信号集操作函数对PCB中这两个集合进行修改；

  • 信号的 “未决” 是一种状态，指的从信号产生到信号被处理前这段时间；

  • 信号的 "阻塞" 是一个开关动作，指的是阻止信号被处理，但不阻止信号产生；

信号的阻塞是为了让系统暂时保留信号等待以后发送。 由于另外有办法让系统忽略信号，所以通常信号的阻塞只是暂时的，是为了防止信号打断某些敏感的操作；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8oIrPH7D-1648192941035)(E:/富贵的编程日记/Linux系统/阻塞-未决信号.png)]

阻塞信号集 和 未决信号集在内核中的结构是相同的。都是一个被封装好的整形数组 ，一共128字节（int [32] ==1024bit）,1024个标志位，其中前31个标志位每个对应Linux中的标准信号 ，通过标志位的值来标记当前信号在信号集中的状态。

# 上图对信号集在内核中存储的状态的描述
# 前31个信号: 1-31 , 对应 1024个标志位的前31个标志位
			信号		标志位(从低地址位 到 高地址位)
		 	  1      ->  	0
			  2             1
			  3             2
			  4             3
			 31            30
  • 在阻塞信号集中，描述这个信号有没有被阻塞：
  1. 默认情况下没有信号被阻塞的，因此信号对应的标志位的值为 0；
  2. 如果某个信号被设置为了阻塞 ， 这个信号对应的标志位 被设置为 1；
  • 在未决信号集中，描述信号是否处于未决状态：
  1. 如果这个信号被阻塞了，不能处理，这个信号对应的标志位被设置为 1；
  2. 如果这个信号的阻塞被解除了，未决信号集中的这个信号马上就被处理，这个信号对应的标志位值变成 0；
  3. 如果信号没有被阻塞，信号产生之后直接被处理，因此不会在未决信号集中做任何记录；
5.3.2 信号集函数

用户不能直接操作内核中的阻塞信号集和未决信号集，必要调用系统函数，关于阻塞信号集可以通过系统函数进行读写操作，未决信号集只能对其进行读操作；

读写信号集函数：

#include <signal.h>
//使用此函数修改内核中的阻塞信号集
//signal_t 被封装之后得到的数据类型，原型：int [32] 有1024个标志位 ，每一个信号对应一个标志位
int sigprocmask(int how , const sigset_t *set , sigset_t *oldset);

参数：

how:

  1. SIG_BLOCK: 将参数set集合中的数据追加到阻塞信号集中；
  2. SIG_UNBLOCK: 将参数set集合中的信号在阻塞信号集中解除阻塞；
  3. SIG_SETMASK: 使用参数 set 集合中的数据覆盖内核的阻塞信号集数据；
  4. oldset：通过此参数将设置之前的阻塞信号集传出，如果不需要可以指定为NULL；

返回值： 函数调用成功返回 0； 调用失败返回 -1；

sigprocmask () 函数有一个 sigset_t 类型的参数，对这种类型的数据进行初始化需要调用一些相关的操作函数：

#include <signal.h>
// 如果在程序中读写 sigset_t 类型的变量
// 阻塞信号集和未决信号集都存储在 sigset_t 类型的变量中, 这个变量对应一块内存
// 阻塞信号集和未决信号集, 对应的内存中有1024bit = 128字节

// 将set集合中所有的标志位设置为0
int sigemptyset(sigset_t *set);
// 将set集合中所有的标志位设置为1
int sigfillset(sigset_t *set);
// 将set集合中某一个信号(signum)对应的标志位设置为1
int sigaddset(sigset_t *set, int signum);
// 将set集合中某一个信号(signum)对应的标志位设置为0
int sigdelset(sigset_t *set, int signum);
// 判断某个信号在集合中对应的标志位到底是0还是1, 如果是0返回0, 如果是1返回1
int sigismember(const sigset_t *set, int signum);

在这里插入图片描述
未决信号集不需要程序猿修改，如果设置了某个信号阻塞，当这个信号产生之后，内核会将这个信号的未决状态记录到未决信号集中，当阻塞的信号被解除阻塞，未决信号集中的信号随之被处理，内核再次修改未决信号集将该信号的状态修改为递达状态（标志位置 0）。因此，写未决信号集的动作都是内核做的，这是一个读未决信号集的操作函数：

#include<signal.h>
//此函数的参数是传出参数 ，传出的内核未决信号集的拷贝；
//读以下这个集合就指定那盒信号是未决状态；
int sigpending(sigset_t *set);

信号集操作函数的使用：

需求：
在阻塞信号集中设置某些信号，通过一些操作产生这些信号，然后读取未决信号集，最后解除这些信号的阻塞；
假设阻塞这些信号：
     --- 2号信号： SIGINT : ctrl + c
     --- 3号信号： SIGQUIT: ctrl + \
     --- 9号信号： SIGKILL：通过shell命令给进程发送这个信号 kill -9 PID

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include <string.h>
#include <signal.h>

int main()
{
    // 1. 初始化信号集
    sigset_t myset;
    sigemptyset(&myset);
    //设置阻塞信号
    sigaddset(&myset,SIGINT); // 2
    sigaddset(&myset,SIGQUIT); //3
    sigaddset(&myset,SIGKILL); //9

    //2 . 将初始化的信号集中的数据设置给内核
    sigset_t old;
    sigprocmask(SIG_BLOCK,&myset,&old);

    //让进程一直运行，在当前进程中产生对于的信号
    int i=0;
    while (1)
    {
        //4. 读内核的未决信号集
        sigset_t curset;
        sigpending(&curset);
        //遍历这个信号集
        for (int i=1;i<32;++i)
        {
            int ret = sigismember(&curset,i);
            printf("%d",ret);
        }
        printf("\n");
        sleep(1);
        i++;
        if (i ==10)
        {
            //解除阻塞 ，重新设置阻塞信号集
            sigprocmask(SIG_SETMASK,&old,NULL);
        }
    }
    return 0;
}

//程序对9号信号的阻塞时无效的 ，9号信号无法被阻塞

信号集操作函数关系：

在这里插入图片描述

1.4 信号捕捉

Linux系统中的每个信号都会有对应的默认处理行为，如果忽略这个信号或者修改某些信号的默认行为就需要在程序中捕捉该信号。程序中进行信号的捕捉可以看作是一个注册动作，提前告知应用程序信号产生之后做什么处理，当信号中对应的信号产生了，该处理动作就会被调用；

1.4.1 signal 函数

使用signal()函数可以捕捉进程中产生的信号，并修改捕捉到的信号行为 ，该信号的自定义处理动作是一个回调函数，内核通过signal()得到这个回调函数的地址，在信号产生后之后该函数会被内核调用；

#include <signal.h>
//在信号产生之前，提供一个注册函数，用来捕捉信号
//       --- 假设将来这个信号产生了，委托内核进行捕捉，这个信号的默认动作就不能被执行
//	   --- 执行什么样的处理动作 -> 在signal 函数中指定的处理动作
//       --- 如果这个信号不产生 ， 回调函数不被执行
sighandler_t signal (int signum , sighandler_t hander);

参数：

  • signum: 需要捕捉的信号；

  • hander: 信号捕捉到之后的处理动作，是一个指针函数，其原型为：

    typedef void (*sighandler_t)(int);

    这个回调函数是需要程序猿写的，但是程序猿不调用，由内核调用，内核调用回调函数的时候，会给它传递一个实参，这个实参的值就是捕捉的那个信号值。

使用signal()函数捕捉定时器产生的信号SIGALRM:

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/time.h>
#include <signal.h>

// 定时器信号的处理动作
void doing(int arg)
{
    printf("当前捕捉到的信号是: %d\n", arg);
    // 打印当前的时间
}

int main()
{
    // 注册要捕捉哪一个信号, 执行什么样的处理动作
    signal(SIGALRM, doing);
    // 1. 调用定时器函数设置定时器函数
    struct itimerval newact;
    // 3s之后发出第一个定时器信号, 之后每隔1s发出一个定时器信号
    newact.it_value.tv_sec = 3;
    newact.it_value.tv_usec = 0;
    newact.it_interval.tv_sec = 1;
    newact.it_interval.tv_usec = 0;
    // 这个函数也不是阻塞函数, 函数调用成功, 倒计时开始
    // 倒计时过程中程序是继续运行的
    setitimer(ITIMER_REAL, &newact, NULL);

    // 编写一个业务处理, 阻止当前进程自己结束, 让当前进程被发出的信号杀死
    while(1)
    {
        sleep(1000000);
    }

    return 0;
}


liu@liu-Ubuntu:~/vscode$ ./signal 
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
当前捕捉到的信号是: 14
^C
1.4.2 sigaction 函数

sigaction() 函数和 signal() 函数功能一样，捕捉进程中的信号，将用户自定义的信号行为函数（回调函数）注册给内核，内核在内核信号产生之后调用这个处理动作。 sigaction() 可认为是 signal() 的加强版，参数复杂一点功能加强点；

#Include <signal.h>
int sigaction(int signum ,const struct sigaction *act , struct sigaction *olddact);

参数：

sigunm: 要捕捉的信号；

act: 捕捉到信号之后的处理动作；

oldact： 上一次调用该函数进行信号捕捉设置的信号处理动作，默认指定 NULL

返回值： 函数调用成功返回 0 ，失败返回 -1；

函数的参数是一个结构体，其原型：

struct sigaction {
	void     (*sa_handler)(int);    // 指向一个函数(回调函数)
	void     (*sa_sigaction)(int, siginfo_t *, void *);
	sigset_t   sa_mask;             // 初始化为空即可, 处理函数执行期间不屏蔽任何信号
	int        sa_flags;	        // 0
	void     (*sa_restorer)(void);  //不用
};

结构体成员：

  • sa_handler : 函数指针 ，指定的函数为捕捉到的信号的处理动作；
  • sa_sigaction : 函数指针 ， 指定的函数为捕捉到的信号的处理动作
  • sa_mask:在信号处理函数执行期间，临时屏蔽某些信号，将要屏蔽的信号设置在集合中即可
  1. 当前处理函数执行完毕，临时屏蔽自动解除
  2. 假设这个集合中不屏蔽任何信号，默认也会屏蔽一个（捕捉信号谁，临时屏蔽谁）
  • sa_flags: 使用那个函数指针指向的函数处理捕捉到的信号；
  1. 0： 使用 sa_handler() 默认使用；
  2. SA_SIGINFO: 使用 sa_sigaction （使用信号传递数据 == 进程间通信）
  • sa_restorer: 被废弃的成员；

通过sigaction()函数捕捉阻塞信号集中的解除阻塞的信号，如果捕捉多个信号，给不同的信号添加不同的处理动作，代码中的处理动作只有一个；

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>

// 信号的处理动作
void callback(int num)
{
    printf("当前捕捉的信号: %d\n", num);
}

int main()
{
    // 1. 初始化信号集
    sigset_t myset;
    sigemptyset(&myset);
    // 设置阻塞的信号
    sigaddset(&myset, SIGINT);  // 2
    sigaddset(&myset, SIGQUIT); // 3
    sigaddset(&myset, SIGKILL); // 9 测试不能被阻塞

    // 当阻塞的信号被解除阻塞, 该信号就可以被捕捉到了
    // 如果信号被捕捉到之后, 马上就被处理掉了 --> 递达状态
    struct sigaction act;
    act.sa_handler = callback;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGINT, &act, NULL);
    // 和sigint的处理动作相同
    sigaction(SIGQUIT, &act, NULL);
    sigaction(SIGKILL, &act, NULL);

    // 2. 将初始化的信号集中的数据设置给内核
    sigset_t old;
    sigprocmask(SIG_BLOCK, &myset, &old);

    // 3. 让进程一直运行, 在当前进程中产生对应的信号
    int i = 0;
    while(1)
    {
        // 4. 读内核的未决信号集
        sigset_t curset;
        sigpending(&curset);
        // 遍历这个信号集
        for(int i=1; i<32; ++i)
        {
            int ret = sigismember(&curset, i);
            printf("%d", ret);
        }
        printf("\n");
        sleep(1);
        i++;
        if(i==10)
        {
            // 解除阻塞, 重新设置阻塞信号集
            //sigprocmask(SIG_UNBLOCK, &myset, NULL);
            sigprocmask(SIG_SETMASK, &old, NULL);
        }
    }
    return 0;
}
//程序中对 9 号信号的捕捉是无效的，因为它无法被捕捉。

1.5 SIGCHLD 信号

当子进程退出、暂停、从暂停回复运行的时候，在子进程中会产生一个 SIGCHLD 信号，并将其发送给父进程 ，但是父进程收到这个信号之后默认就忽略了。我们可以在父进程中对这个信号加以利用，基于这个信号来回收子进程的资源，因此需要在父进程中捕捉子进程发送过来的这个信号

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <signal.h>

// 回收子进程处理函数
void recycle(int num)
{
    printf("捕捉到的信号是: %d\n", num);
    // 子进程的资源回收, 非阻塞
    // SIGCHLD信号17号信号, 1-31号信号不支持排队
    // 如果这些信号同时产生多个, 最终处理的时候只处理一次
    // 假设多个子进程同时退出, 父进程同时收到了多个sigchld信号
    // 父进程只会处理一次这个信号, 因此当前函数被调用了一次, waitpid被调用一次
    // 相当于只回收了一个子进程, 但是是同时死了多个子进程, 因此就出现了僵尸进程
    // 解决方案: 循环回收即可
    while(1)
    {
        // 如果是阻塞回收, 就回不到另外一个处理逻辑上去了
        pid_t pid = waitpid(-1, NULL, WNOHANG);
        if(pid > 0)
        {
            printf("child died, pid = %d\n", pid);
        }
        else if(pid == 0)
        {
            // 没有死亡的子进程, 直接退出当前循环
            break;
        }
        else if(pid == -1)
        {
            printf("所有子进程都回收完毕了, 拜拜...\n");
            break;
        }
    }
}


int main()
{
    // 设置sigchld信号阻塞
    sigset_t myset;
    sigemptyset(&myset);
    sigaddset(&myset, SIGCHLD);
    sigprocmask(SIG_BLOCK, &myset, NULL);

    // 循环创建多个子进程 - 20
    pid_t pid;
    for(int i=0; i<20; ++i)
    {
        pid = fork();
        if(pid == 0)
        {
            break;
        }
    }

    if(pid == 0)
    {
        printf("我是子进程, pid = %d\n", getpid());
    }
    else if(pid > 0)
    {
        printf("我是父进程, pid = %d\n", getpid());
        // 注册信号捕捉, 捕捉sigchld
        struct sigaction act;
        act.sa_flags  =0;
        act.sa_handler = recycle;
        sigemptyset(&act.sa_mask);
        // 注册信号捕捉, 委托内核处理将来产生的信号
        // 当信号产生之后, 当前进程优先处理信号, 之前的处理动作会暂停
        // 信号处理完毕之后, 回到原来的暂停的位置继续运行
        sigaction(SIGCHLD, &act, NULL);

        // 解除sigcld信号的阻塞
        // 信号被阻塞之后,就捕捉不到了, 解除阻塞之后才能捕捉到这个信号
        sigprocmask(SIG_UNBLOCK, &myset, NULL);

        // 父进程执行其他业务逻辑就可以了
        // 默认父进程执行这个while循环, 但是信号产生了, 这个执行逻辑或强迫暂停
        // 	父进程去处理信号的处理函数
        while(1)
        {
            sleep(100);
        }
    }
    return 0;
}
富贵的编程日记
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux操作系统下C语言编程快速入门
05-13
Linux操作系统下C语言编程快速入 资料中有错误部分，在看时请注意。 不过本人觉的资料还不错。 第一章 基础知识 ....................................................................................... 4 10 第二章 进程介绍 .................................................................................... 第三章 文件操作 .................................................................................... 第四章 时间概念 .................................................................................... 第五章 信号处理 .................................................................................... 第六章 消息管理 .................................................................................... 第七章 线程操作 .................................................................................... 第八章 网络编程 .................................................................................... 第九章 Linux 下 C 开发工具介绍 17 27 31 39 49 54
基于linux下的高并发服务器开发（第二章）- 2.20 kill、raise、abort函数
呵呵哒!的博客
07-21 568
首先：sudo service apport stop。
【Linux篇】第十三篇——信号（概念+信号的产生+阻塞信号+捕捉信号）
m0_58367586的博客
10-03 3496
而操作系统是软硬件资源的管理者，在程序运行过程中，若操作系统发现CPU内的某个状态标志位被置位，而这次置位就是因为出现了某种除0错误而导致的，那么此时操作系统就会马上识别到当前是哪个进程导致的该错误，并将所识别到的硬件错误包装成信号发送给目标进程，本质就是操作系统去直接找到这个进程的task_struct，并向该进程的位图中写入8信号，写入8号信号后这个进程就会在合适的时候被终止。查看这两个信号的默认处理动作，可以看到这两个信号的action是不一样的，2号信号是term,而三号信号是core.
Signal 13 was raised（SIGPIPE管道破裂）
热门推荐
jia12216的专栏
03-10 1万+
管道另一端没有进程接收数据，导致管道破裂而崩溃。 socket或管道，当自己主动关闭，资源被苹果系统回收，对方关闭时，当再次通过socket或pipe的文件描述符发送消息会出现系统级别的崩溃（管道破裂，signal 13。它的级别和内存使用或释放异常一直，由于是系统级别崩溃，所以不能通过@try{}@catch (NSException *exception) { }捕获到异常，而是直接ap
Linux操作系统 - 信号
weixin_43164548的博客
04-01 2992
进程间通信的另一种方式-信号，从信号的种类、产生、捕捉、处理入手来认识信号
信号13 linux,linux信号
weixin_36156325的博客
05-14 490
各种SignalsSignalDescriptionSIGABRT由调用abort函数产生，进程非正常退出SIGALRM用alarm函数设置的timer超时或setitimer函数设置的interval timer超时SIGBUS某种特定的硬件异常，通常由内存访问引起SIGCANCEL由Solaris Thread Library内部使用，通常不会使用SIGCHLD进程Terminate或Stop...
Linux-------12----13----信号描述 及编程实战
weixin_42714122的博客
09-15 137
Linux-------12----13----信号描述 及编程实战
Message from debugger: Terminated due to signal 13
程序猿老樊的博客
09-30 2173
在偶然调试APP直播的时候，在iOS 13系统上发现当处于播放视频状态的时候，退出直播，会出现APP闪退。 但与平常闪退情况不同的是，链接编译器调试的时候，编译器不会捕捉到相关的crash信息，编译器与手机的链接会直接中断。 编译器只给出 Message from debugger: Terminated due to signal 13 这个错误信息。接下来就只有顺着signal 13信号这个线索进行研究。 简单来讲就是管道破裂。管道破裂，这个信号通常在...
Linux程序崩溃时的信号量（signal）说明
咸鱼弟的博客
10-06 2625
Linux程序崩溃时的信号量（signal）说明，exception 7 11 15
关于Flutter使用socket在iOS下报 Terminated due to signal 13的采坑记录
Lester的博客
12-26 4358
flutter socket iOS Terminated due to signal 13
入门学习Linux常用必会60个命令实例详解doc/txt
06-09
入门学习Linux常用必会60个命令实例详解 Linux必学的60个命令 Linux提供了大量的命令，利用它可以有效地完成大量的工作，如磁盘操作、文件存取、目录操作、进程管理、文件权限设定等。所以，在Linux系统上工作离不...
redhat linux教材20课程学习文档
04-24
4.4 在文件中快速移动光标 4.4.1 基本的移动方式 4.4.2 在同一行中移动光标 4.4.3 在页面间移动光标 4.4.4 在底线模式下移动光标 4.4.5 查找字符或者文字 4.5 在文件中替换和删除文本 4.5.1 命令模式中的替换命令 ...
qt开发入门介绍.zip
最新发布
05-02
Qt开发入门主要包括以下几个方面的介绍： Qt概述： Qt是一个跨平台的C++应用程序开发框架，由Qt Company（前身为Nokia）开发。它支持Windows、macOS、Linux、Android和iOS等多个操作系统。 Qt框架提供了丰富的功能...
嵌入式Linux应用程序开发标准教程(第2版全)
10-11
第1章 Linux快速入门 1.1 嵌入式Linux基础 1.1.1 Linux发展概述 1.1.2 Linux作为嵌入式操作系统的优势 1.1.3 Linux发行版本 1.1.4 如何学习Linux 1.2 Linux安装 1.2.1 基础概念 1.2.2 硬件需求 1.2.3 安装准备 1.3 ...
linux-journal日志文件特别大怎么办，journal日志文件学习
你是我的天晴
04-28 294
今天发现磁盘容量不多了，就去清理磁盘，发现这个文件特别大：journal，特此来学习下。
『Linux』 第一章 基本操作指令（上）
m0_54443558的博客
04-28 1005
Linux 基本指令
获取Java 虚拟机进程ID（java应用进程Id的方法） Linux & windows
weixin_44131922的博客
04-30 420
这个命令会列出所有包含"java"的进程信息。从中你可以找到你的Java应用对应的进程行，第一列就是进程ID（PID）。这个命令会列出所有包含"java"的进程信息。在输出的信息中，你可以找到Java进程及其PID。替换为你的Java主类名或jar文件名的部分匹配字符串，pgrep会直接返回对应的进程ID。如果你需要在Java程序内部获取其自身的进程ID，可以使用。这段代码会打印出当前运行Java程序的进程ID。
Linux：浏览器访问网站的基本流程（优先级从先到后）
fox_kang的博客
04-28 763
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
Linux 第十八章
一怀明月的博客
05-01 1245
程序地址空间 区间的地址分布 真正理解同一个地址进行读取不同内容 地址空间 虚拟地址和物理地址 虚拟地址： 物理地址： struct mm_struct 页表
labview2021sp1专业版 linux下载
06-06
LabVIEW 2021 SP1专业版已经支持Linux系统，用户可以通过NI官网进行下载。首先需要进行注册账号，并购买相应的软件授权，然后在NI网站上选择“产品和服务”、“软件下载”，找到“LabVIEW”软件，在“平台”中选择“Linux”，选择相应的版本进行下载。 在下载并安装完成后，建议用户检查系统环境和依赖库是否满足LabVIEW的运行要求，确保软件可以正常运行。此外，LabVIEW针对不同的软件环境提供了相应的快速入门和使用说明，用户可以按照文档进行操作，快速上手。 总的来说，LabVIEW 2021 SP1专业版为用户在Linux系统下进行数据采集、实时控制、信号处理和深度学习等应用提供了高效和便捷的开发工具。用户只需要下载并按照文档操作，即可快速使用其中的各种功能模块，满足自己的应用需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值