Linux 信号 2019.1.8（信号的实现机制，信号状态，阻塞信号集和未决信号集，raise，abort，alarm，setitimer，信号捕捉，利用SIGCHLD回收子进程）

最新推荐文章于 2023-05-11 20:48:24 发布
最新推荐文章于 2023-05-11 20:48:24 发布
阅读量563 收藏 2
点赞数 1
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/86013388
版权

学习目标

 

推荐使用sigaction，因为不同平台是signal可能不一样

 

信号的特点

简单，不能携带大量信息，满足特定条件才会发生。信号也叫软中断，有可能会有延迟。

 

信号的实现机制

信号实际上是由内核发送，内核来处理收到的信号。收到信号的进程，必须对信号做出处理（忽略，捕获，默认动作都行）

 

产生信号

 

信号状态

  • 产生
  • 递达——信号到达并且处理完
  • 未决——信号被阻塞

 

信号的默认处理方式

  • 忽略
  • 默认动作
  • 捕获

 

信号的四要素

  • 编号
  • 事件
  • 名称
  • 默认处理动作

默认处理动作有五个（linux 输入  man 7 signal 即可查看），如图所示：

注意：9号，19号信号，不能捕捉，不能忽略，不能阻塞。

 

 

 

阻塞信号集和未决信号集

处理了就把二进制位设置为0，未处理就设置为1.

阻塞信号集的作用是影响未决信号集，相当于给他挡了一堵墙。

如果我们把2号信号设置成阻塞（即在阻塞信号集的对应位置设为1），那么来一个2号信号，则未信号集的对应值置为1，什么时候阻塞信号集中的对应位置变成0了，什么时候未决信号集才能去处理之前被阻塞的那个信号。

 

 

信号的产生

 

系统api产生信号

 

kill函数

int kill(pid_t pid, int sig);
  • pid > 0 ,要发送进程ID
  • pid = 0, 代表当前调用进程中内所有进程
  • pid = -1, 代表有权限发送的所有进场
  • pid < 0,代表 -pid 对应的组内所有进程
  • sig 对应的信号

 

练习，让3号子进程杀死父进程

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<signal.h>

int main(){
	int i;
	for(i=0; i<5; i++){
		pid_t pid=fork();
		if(pid==0){
			break;
		}
	}
	//我们使3号子进程杀死父进程
	if(i==2){
		printf("I will kill my father after 5 second!\n");
		sleep(5);
		kill(getppid(),SIGKILL);
	}
	if(i==5){
		while(1){
			printf("I am father, very happy!\n");
			sleep(1);
		}
	}
	return 0;
}

运行结果

 

再来一个父进程把3号子进程杀死

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<signal.h>

int main(){
	int i=0;
	pid_t pid3, pid;
	for(i=0; i<5; i++){
		pid=fork();
		if(pid==0) break;
		if(i==2) pid3=pid;
	}
	if(i<5){
		while(1){
			printf("I am child, pid=%d, ppid=%d\n", getpid(), getppid());
			sleep(3);
		}
	}
	else if(i==5){
		printf("I am father,pid=%d, I will kill xiao san pid3=%d\n", getpid(), pid3);
		sleep(5);
		kill(pid3, SIGKILL);
		while(1) sleep(1);
	}
	return 0;
}

运行结果：pid15537不见了

 

 

raise——给自己发送信号

#include<stdio.h>
#include<sys/types.h>
#include<signal.h>
#include<unistd.h>

int main(){
	printf("I will die!\n");
	sleep(2);
	raise(SIGKILL);//kill(getpid(), sig)
	return 0;
}

运行结果：

实际上调用的是kill

 

abort——直接给自己发送异常信号，直接退出

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

int main(){
	printf("I will die!\n");
	sleep(2);
	abort();//kill(getpid(), sig)
	return 0;
}

运行结果：

 

 

 

时钟信号

 

alarm

  • 定时给自己发送SIGALRM
  • 几秒后发送信号
  • 返回值——上次闹钟剩余的秒数
  • 特别的，如果传入参数秒为0，代表取消闹钟
#include<stdio.h>
#include<unistd.h>

int main(){
	alarm(6);
	while(1){
		printf("lai da wo!\n");
		sleep(1);
	}
	return 0;
}

运行结果

 

我们来看alarm函数的返回值

#include<stdio.h>
#include<unistd.h>

int main(){
	int ret=0;
	ret=alarm(6);
	printf("ret=%d\n", ret);
	sleep(2);
	ret=alarm(5);
	printf("ret=%d\n", ret);
	while(1){
		printf("lai da wo!\n");
		sleep(1);
	}
	return 0;
}

运行结果

 

 

setitimer函数——周期性的发送信号

 

结构体——结构体中嵌套了两个结构体

 

函数原型

int settime(int which, const struct itimerval *new_value, struct itimerval *old_value);)
  • which
  1. ITIMER_REAL 自然定时法 SIGALRM
  2. ITIMER_VIRTUAL 计算进程执行时间 SIGVTALRM
  3. ITIMER_PROF 程序执行时间+调度时间 ITIMER_VIRTUAL
  • new_value 要设置的闹钟时间
  • old_value 原闹钟时间

 

setitimer实现alarm功能

#include<stdio.h>
#include<sys/time.h>
#include<unistd.h>

int main(){
	//setitimer是一个结构体中嵌套了两个结构体
	//两个结构体分别代表：周期性的时间设置，下次的闹钟时间
	//每个结构体里。，第一个参数是秒，第二个参数是微妙
	//这里定义的意思就是：三秒之后发送SIGALRM信号
	struct itimerval myit={{0,0},{3,0}};
	setitimer(ITIMER_REAL, &myit, NULL);

	while(1){
		printf("Who can kill me!\n");
		sleep(1);
	}
	return 0;
}

运行结果

 

 

测试周期性发送信号功能

周期性发送SIGALRM信号杀死进程，进程利用catch_sig函数来捕获SIGALRM信号

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

void catch_sig(int num){
	printf("cat %d sig\n", num);
}
int main(){
	signal(SIGALRM, catch_sig);
	//第一次等待五秒，之后每隔三秒
	struct itimerval myit={{3,0},{5,0}};
	setitimer(ITIMER_REAL, &myit, NULL);

	while(1){
		printf("Who can kill me!\n");
		sleep(1);
	}
	return 0;
}

运行结果

 

 

setitimer实现alarm

#include<stdio.h>
#include<unistd.h>
#include<sys/time.h>

unsigned int myalarm(unsigned int seconds){
	struct itimerval oldit,myit={{0,0},{0,0}};
	//second秒之后，给我发送一个SIGALRM信号
	myit.it_value.tv_sec=seconds;
	//old_value 原闹钟时间
	setitimer(ITIMER_REAL, &myit, &oldit);
	//打印秒和微秒
	printf("tv_sec=%ld, tv_microsec=%ld\n",
		oldit.it_value.tv_sec, oldit.it_value.tv_usec);
	return oldit.it_value.tv_sec;

}

int main(){
	int ret=0;
	ret=myalarm(5);
	printf("ret=%d\n", ret);
	sleep(3);
	ret=myalarm(3);
	printf("ret=%d\n", ret);
	while(1){
		printf("lai da wo!\n");
		sleep(1);
	}
	return 0;
}

 

 

 

信号集的操作函数

输入可查看信号集出来函数的man手册

man sigemptyset
  •  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——判断是否为集合里的成员——返回 1 代表在集合中
  •  int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);——用来设置或者解除阻塞信号集
  • int sigpending(sigset_t *set);——获取未决信号集

 

输入命令，查看另一个信号集函数——sigprocmask——用来设置或者解除阻塞信号

man sigprocmask

  • how
  1. SIG_BLOCK 设置阻塞
  2. SIG_UNBLOCK 解除阻塞
  3. SIG_SETMASK 设置set为新的阻塞信号集
  • set 传入的信号集
  • oldset 旧信号集，传出

 

 

输入命令，查看另一个信号集函数——sigpending——用来获取未决信号集

man sigpending

  • set 传出参数，当前的未决信号集

 

 

把所有常规信号的未决信号集打到屏幕上

将2号信号（ctrl+c）放在阻塞信号集上，这样该信号在未决信号集上会进行保留

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

int main(){
	sigset_t pend, sigproc;
	//设置阻塞信号，等待按键产生信号
	//先清空
	sigemptyset(&sigproc);
	//将2号信号(ctrl+c)放在集合里
	sigaddset(&sigproc, SIGINT);
	//设置阻塞信号集
	sigprocmask(SIG_BLOCK, &sigproc, NULL);

	//循环取未决信号集中的信号
	while(1){
		//循环读取未决信号，打印
		sigpending(&pend);
		for(int i=0; i<32; i++){
			//存在信号集中
			if(sigismember(&pend, i)==1){
				printf("1");
			}else{
				printf("0");
			}
		}
		printf("\n");
		sleep(1);
	}

	return 0;
}

 

 

 

 

信号捕捉

 

防止进程意外死亡

输入查看函数原型

man signal
  • typedef void (*sighandler_t)(int);
  • sighandler_t signal(int signum, sighandler_t handler);
  1. signum 要捕捉的信号
  2. handler 要执行的捕捉函数指针，函数应该声明 void func(int);//函数名可变

 

输入查看函数原型

man sigaction
  • int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
  1. signum 捕捉的信号
  2. act 传入的动作
  3. oldact 原动作

 

捕捉我们定时给自己发送的14号自杀信号

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

//定义捕捉函数
void catch_sig(int num){
	printf("catch %d sig\n", num);
}

int main(){
	//注册捕捉函数
	struct sigaction act;
	//说明为你使用的是sigaction结构体中的第一个捕捉函数
	act.sa_flags=0;
	//那个捕捉函数的函数指针指向我们上面自己写的捕捉函数catch_sig
	act.sa_handler=catch_sig;
	//清空信号集
	sigemptyset(&act.sa_mask);
	sigaction(SIGALRM, &act, NULL);

	//setitimer 5秒之后每隔3秒来一次信号
	struct itimerval myit={{3,0},{5,0}};
	setitimer(ITIMER_REAL, &myit, NULL);
	while(1){
		printf("Who can kill me!\n");
		sleep(1);
	}	
	return 0;
}

 

 

信号捕捉的特性

 

 

 

内核实现信号捕捉过程

 

 

 

利用SIGCHLD回收子进程

子进程在暂停或者退出的时候会发送SIGCHLD信号，我们可以通过捕捉SIGCHLD信号来回收子进程。

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

void catch_sig(int num){
	pid_t pid=waitpid(-1, NULL, WNOHANG);
	if(pid>0){
		printf("wait child %d ok\n", pid);
	}
}

int main(){
	int i=0;
	pid_t pid;
	for(i=0; i<10; i++){
		pid=fork();
		if(pid==0){
			break;
		}
	}
	if(i==10){
		//father
		struct sigaction act;
		act.sa_flags=0;
		sigemptyset(&act.sa_mask);
		act.sa_handler=catch_sig;
		sigaction(SIGCHLD, &act, NULL);
		while(1){
			sleep(1);
		}
	}else if(i<10){
		printf("I am %d child, pid=%d\n", i, getpid());
		sleep(i);
	}
	return 0;
}

上面的程序是有问题的，如果我十个孩子不是依次死去，而是一起死，就会出现僵尸进程，因为信号不排队的。

 

改进一下上面的代码，让他不出僵尸进程。我们即将信号收集函数catch_sig里面用一个while循环来循环处理pid收集到的各个SIGCHLD信号。

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

void catch_sig(int num){
	pid_t pid;
	//此时，如果多个子进程一起死，pid对获得多个信号
	while((pid=waitpid(-1, NULL, WNOHANG))>0) {
		if(pid>0){
			printf("wait child %d ok\n", pid);
		}
	}	
}

int main(){
	int i=0;
	pid_t pid;
	for(i=0; i<10; i++){
		pid=fork();
		if(pid==0){
			break;
		}
	}
	if(i==10){
		//father
		struct sigaction act;
		act.sa_flags=0;
		sigemptyset(&act.sa_mask);
		act.sa_handler=catch_sig;
		sigaction(SIGCHLD, &act, NULL);
		while(1){
			sleep(1);
		}
	}else if(i<10){
		printf("I am %d child, pid=%d\n", i, getpid());
	}
	return 0;
}

 

如果注册sigaction之前，子进程就死了，那么还是会产生僵尸进程。如何避免？

子进程死之前，如果main函数还没注册sigaction，就把SIGCHLD信号屏蔽即可。屏蔽信号的工作，应该在创建子进程之前就开始去做，如此可以避免极端情况下出现差错。

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

void catch_sig(int num)
{
    pid_t wpid ;
    while( (wpid = waitpid(-1,NULL,WNOHANG)) > 0   ){
        printf("wait child %d ok\n",wpid);
    }
    
}

int main()
{
    int i =0;
    pid_t pid ;

    //在创建子进程之前屏蔽SIGCHLD信号
    sigset_t myset,oldset;
    sigemptyset(&myset);
    sigaddset(&myset,SIGCHLD);
    //oldset 保留现场，设置了SIGCHLD到阻塞信号集
    sigprocmask(SIG_BLOCK,&myset,&oldset);

    for(i = 0 ; i < 10 ; i ++){
        pid =fork();
        if(pid == 0 ){
            break;
        }
    }

    if(i == 10 ){
        //parent 
		//模拟注册晚于子进程死亡
        sleep(2);
        struct sigaction act ;
        act.sa_flags  = 0;
        sigemptyset(&act.sa_mask);
        act.sa_handler = catch_sig;

        sigaction(SIGCHLD,&act,NULL);
        
        //解除屏蔽现场
        sigprocmask(SIG_SETMASK,&oldset,NULL);

        while(1){
            sleep(1);
        }
    }else if(i < 10){
        printf("I am %d child,pid = %d\n",i,getpid());
    }

    return 0;
}

 

 

作业：利用SIGUSR1和SIGUSR2在父子进程之间进行消息传递，实现父子进程交替报数（间隔1s）

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<fcntl.h>
#include <signal.h>
#include<sys/types.h>
pid_t pid;
int count =0;
int flag = 0;

void cat_sig_father(int num)
{
    sleep(1);
	//父进程将自己的flag改成1
    flag = 1;
    printf("%d\n",count);
    count +=2;
    //    kill(pid,SIGUSR2);
}
void cat_sig_child(int num)
{
    sleep(1);
	//子进程中的flag变成1
    flag = 1;
    printf("%d\n",count);
	//因为交替数数，所以cout+2
    count +=2;
    //    kill(getppid(),SIGUSR1);
}

int main(int argc,char *argv[]){
    pid = fork();
    if(pid == 0) {
        //son
        count=1;
		//捕捉SIGUSR2信号，捕捉到之后，执行函数cat_sig_child
        signal(SIGUSR2,cat_sig_child);
		//获取父进程id
        pid_t ppid = getppid();

        while(1){
			//flag的值为1时，向父进程发送SIGUSR1信号
            if(flag == 1){
                kill(ppid,SIGUSR1);
                flag = 0;
            }
        }
    }
    else{
		//父进程睡了10微秒
        usleep(10);
		//count的值父子进程不共享
        count=2;
		//注册SIGUSR1
        signal(SIGUSR1,cat_sig_father);
		//给子进程发送SIGUSR2信号
        kill(pid,SIGUSR2);
        //printf("begin ...\n");
        while(1){
            if(flag == 1){
				//给子进程发送SIGUSR2信号
                kill(pid,SIGUSR2);
                flag = 0;
            }
        }

    }
    return 0;
}

 

将上面函数cat_sig_father和cat_sig_child中的sleep()都注释掉之后，会发生卡死的情况。

因此，当系统负荷严重的时候，信号极不稳定

 

产生卡死的原因：

当子进程执行完kill函数之后，此时发生中断，flag=0这句还没执行。

       while(1){
			//flag的值为1时，向父进程发送SIGUSR1信号
            if(flag == 1){
                kill(ppid,SIGUSR1);
                flag = 0;
            }
        }

此时父进程收到了信号，执行cat_sig_father函数，将自己的flag改成1，然后发送信号SIGUER2给子进程，父进程的flag变为0。

此时获取了cpu的子进程收到了信号，收到信号要优先处理信号，于是去执行上面的signal函数

        //捕捉SIGUSR2信号，捕捉到之后，执行函数cat_sig_child
        signal(SIGUSR2,cat_sig_child);
		//获取父进程id
        pid_t ppid = getppid();

        while(1){
			//flag的值为1时，向父进程发送SIGUSR1信号
            if(flag == 1){
                kill(ppid,SIGUSR1);
                flag = 0;
            }
        }

而此时子进程的flag值为0，进程无法进入while循环，也就无法向父进程发送信号，此时父子进程的flag的值都为0，因此就卡死了。

 

王小闹儿
关注
专栏目录
Linux——用C实现子进程借助信号回收
qq_37299596的博客
05-04 581
//放了个五一小假，对于什么时候返校似乎心态上稍微平和一点了，总之，无论如何都是要抓紧在家学的时间，10号争取把网络编程都学完吧，然后要开始做项目和刷题，不简单会困难，但是都是要一一面对去克服的，所以啊躲避往后拖不但没有用反而会让事情变糟糕的=== 还有好多要学，每天都要加油啊????在每天都学习的基础上，以后能走到哪一步就算哪一步吧xX //整理复习子进程借助信号进行回收 1，既然是子进程回收，那首先...
Linux C/C++编程之（十八）信号产生和处理
种树最好的时间是10年前，其次是现在！！！
07-08 6905
文章目录一、概述二、信号详解1. 信号的概念2. 信号的机制3. 与信号相关的事件和状态4. 信号的处理方式5. 信号的编号6. 信号4要素7. Linux常规信号一览表8. 信号的产生9. 信号集操作函数 一、概述 二、信号详解 1. 信号的概念 信号在我们的生活中随处可见， 如：古代战争中摔杯为号；现代战争中的信号弹；体育比赛中使用的信号枪…他们都有共性： 1） 简单 2）不能携带大量信息 3）满足某个特设条件才发送。 信号是信息的载体，Linux/UNIX 环境下，古老、经典的通信方式， 现下依然
linux系统编程之信号（五）：信号集操作函数，信号阻塞与未决
diehuojiang5959的博客
07-15 291
一，信号集及相关操作函数 信号集被定义为一种数据类型： typedef struct { unsigned long sig[_NSIG_WORDS]； } sigset_t 信号集用来描述信号的集合，每个信号占用一位（64位）。Linux所支持的所有信号可以全部或部分的出现在信号集中，主要与信号阻塞相关函数配合使用。下面是为信号集操作定义的...
信号集（未决信号集，阻塞信号集）
goodgoodstudy___的博客
06-04 430
信号集
linux系统编程之阻塞信号集和未决信号集
蜀沐的博客
03-10 237
linux系统编程之阻塞信号集和未决信号集 --------调用kill函数，用第三个子进程杀死父进程 #include<stdio.h> #include<unistd.h> #include<sys/typr.h> #include<signal.h> int main() { int i=0; for(i=0;i<5;i++) { pid_t pid=fork(); if(pid==0) {
01--Linux系统编程-信号.docx
11-10
在Linux/UNIX环境中，信号自早期版本起就被引入，并随着时间的推移逐渐演变为可靠的通信手段，尽管在不同的实现中存在一些不兼容性，但POSIX.1标准的制定统一了可靠信号的处理。 信号的机制类似于硬件中断，但它们...
Linux 进程信号深剖
qq_61500888的博客
11-28 7593
带你一命通关 Linux 进程信号原理 三十分钟手撕底层内涵
Linux---信号详解
weixin_53946312的博客
01-12 2743
信号
29.阻塞信号集和未决信号集的概念
Disappear_XueChao的博客
07-05 791
1.存在于PCB中2.不能直接操作3.阻塞信号集：　　要屏蔽的信号未决信号集：　　没有处理的信号的集合
40-阻塞信号与未决信号
进击的小学生
12-26 2200
有时候，你并不希望你的进程处理信号。比如接收到 SIGINT 后对它置之不理。linux 提供了一个函数 sigprocmask 来帮助我们实现此功能。在一个进程中，保存了两个信号集（在PCB中），分别是阻塞信号集，还有一个未决信号集。当你使用 sigprocmask 的时候，就会修改阻塞信号集。有关未决信号集请本文看第 2 节。如果一个信号加加入阻塞信号集，该信号的信号处理函数就不会被调用。1.
利用信号回收僵尸子进程
qq_22753933的博客
10-30 398
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;unistd.h&gt; #include &lt;errno.h&gt; #include &lt;sys/type.h&gt; #include &lt;sys/wait.h&gt; #include &lt;signal.h&gt; void sys_err(ch
linux信号的阻塞和未决
Be The Best！
12-17 6379
执行信号的处理动作称为信号递达（Delivery），信号从产生到递达之间的状态，称为信号未决（Pending）。 进程可以选择阻塞（Block）某个信号。被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。注意，阻塞和忽略是不同，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作。
Linux学习之系统编程篇： 阻塞信号集、未决信号集、自定义信号集
weixin_42374938的博客
07-21 172
阻塞信号集和未决信号集在内核 PCB 中，因此我们无法操作，但是可以操作自定义信号集，然后将其通过函数映射给阻塞信号集来间接操作。 信号集本质：位图（1-31 号）
linux系统(信号)07_信号的概念，阻塞信号集_未决信号集_信号的产生，raise和abort，alarm发送信号，setitime使用，信号集的函数，sigaction捕捉setitimer产生
最新发布
weixin_41865866的博客
05-11 254
信号的概念，阻塞信号集_未决信号集_信号的产生，raise和abort，alarm发送信号，setitime使用，信号集的函数，sigaction捕捉setitimer产生
linux环境编程-通过信号完成子进程回收
qq_44065088的博客
10-12 267
当子进程死翘翘的时候，会给父进程发出一个信号-----SIGCHLD，但是这个信号也不是仅仅由于子进程死亡而产生的 先来看看SIGCHLD信号的长生条件 子进程终止时【常常的发生】 子进程接收到SIGSTOP信号停止时 子进程处于停止状态，接收到SIGCONT后唤醒时 前面的文章我们已经介绍了 waitpid函数 现在我们来用一用 代码Demo【有问题的代码】 #include <iostream> #include <signal.h> #include <e.
信号（上）：信号的简单介绍，阻塞信号集和未决信号集，系统关于信号的函数kill,raise,abort,alsrm时钟信号，setitimer函数，捕捉函数signal，setitimer实现alar
weixin_43767691的博客
07-10 321
信号的概念：由内核发出并处理 信号四要素： ⦁ 编号 ⦁ 名称 ⦁ 时间 ⦁ 默认处理动作 终止 忽略 终止，产生 暂停，继续 信号的特点： 简单 不能携带大量信息 特定条件下产生 信号也叫软中断，可能会有延迟 信号的处理方式： ⦁ 执行默认动作 ⦁ 捕捉 ⦁ 忽略 9.19号信号不能捕捉，不能忽略，甚至不能阻塞 阻塞信号集(信号屏蔽字)和未决信号集：要想理解信号函数，先理解未...
信号（阻塞未达 信号集）
Cyber
05-17 208
信号的阻塞未达信号在操作系统内核的传递过程中，执行信号的处理动作称为信号递达（Delivery），信号从产生到递达之间的状态，称为信号未决（Pending）。进程可以选择阻塞（Block）某个信号。被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。（注：阻塞和忽略是不同，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作。）信号在内核中的表示如图：PCB...
深入解析Linux信号：阻塞、投递与处理机制
本文档深入探讨了Linux操作系统下的信号机制，重点关注了信号的阻塞和投递原理。信号是内核与进程通信的一种方式，它们的状态可以是阻塞、未决或递达。信号阻塞是指进程选择不让特定信号被处理，而信号未决则表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值