【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法

这篇具有很好参考价值的文章主要介绍了【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

阻塞信号

信号相关概念

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

内核中的表示

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

  • 每个信号都有两个标志位分别表示 阻塞(block)未决(pending) ,还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志
  • 在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
  • SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
  • SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler()。 如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里,本文不讨论实时信号。

处理方法举例:

if( (1<<(signo - 1))& pcb->block )
{
    // signo信号是被阻塞的,不抵达
}
else
{
    if((1<<(signo - 1)) &pcb-> pending)
    {
        // 递达该信号
    }
}
  • 数组的位置(下标),信号的编号
  • 数组下标对应的内容,表示对应信号的处理方法

如果一个信号没有产生,并不妨碍它可以先被阻塞

sigset_t

由上图得知:每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。

因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。下面将详细介绍信号集的各种操作。

阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略

信号集操作函数

sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储这些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 sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
int sigpending(sigset_t *set);
int sigismember(const sigset_t *set, int signo);
  • 函数sigemptyset:初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含任何有效信号。
  • 函数sigfillset:初始化set所指向的信号集,使其中所有信号的对应bit填满,表示该信号集的有效信号包括系统支持的所有信号。
  • 函数sigaddset:向信号集set中添加信号signo
  • 函数sigdelset :从信号集set中删除信号signo
  • 函数sigprocmask:是一个系统调用,用于控制进程的信号掩码
  • 函数sigpending:用于获取当前被阻塞(pending)的信号集合
  • 函数sigismember :判断信号signo是否属于信号集set,如果是则返回非零值,否则返回零。
  • 注意:在使用sigset_ t类型的变量之前,一定要调用sigemptysetsigfillset初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

前六个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含某种信号,若包含则返回1,不包含则返回0,出错返回-1。

sigprocmask

函数功能:
sigprocmask函数用于获取或更改当前进程的信号掩码。信号掩码是一个位向量,用于控制进程是否接收某些信号的通知。使用sigprocmask函数,可以阻塞、解除阻塞或替换当前进程的信号掩码。

函数原型:

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

函数参数:

  • how:一个整数,指定如何修改进程的信号掩码。可以是以下三个值之一:
    1.SIG_BLOCK:将set中指定的信号添加到进程的信号掩码中。
    2.SIG_UNBLOCK:将set中指定的信号从进程的信号掩码中删除。
    3.SIG_SETMASK:用set中指定的信号替换进程的信号掩码。
  • set:一个指向sigset_t类型的指针,指定要添加、删除或替换的信号集合。如果how的值SIG_UNBLOCK,则忽略此参数。
  • oldset:一个指向sigset_t类型的指针,用于存储调用前的信号掩码。如果不需要此信息,则可以将其设置为NULL

函数返回值:
如果成功,返回0。如果失败,返回-1,并设置errno以反映错误的原因。

sigpending

函数原型:

int sigpending(sigset_t *set);

函数功能:
sigpending函数用于获取当前被阻塞(pending)的信号集合。挂起的信号是一些当前已经发送给进程但是还没有被处理的信号。

函数参数:

  • set:一个指向sigset_t类型的指针,用于存储被阻塞的信号集合。

函数返回值:
如果成功,返回0,如果失败,返回-1,并设置errno以反映错误的原因。

小实验 - 观察pending表

实验:发送一个信号,如果被屏蔽那么这个信号就不会被递达,然后存放入pending表

#include <iostream>
#include <vector>
#include <signal.h>
#include <unistd.h>

// #define BLOCK_SIGNAL 2
#define MAX_SIGNUM 31

using namespace std;

// static vector<int> sigarr = {2,3};
static vector<int> sigarr = {2};

static void show_pending(const sigset_t &pending)
{
    for(int signo = MAX_SIGNUM; signo >= 1; signo--)
    {
        if(sigismember(&pending, signo))
        {
            cout << "1";
        }
        else cout << "0";
    }
    cout << "\n";
}

static void myhandler(int signo)
{
    cout << signo << " 号信号已经被递达!!" << endl;
}

int main()
{
    for(const auto &sig : sigarr) signal(sig, myhandler);

    // 1. 先尝试屏蔽指定的信号
    sigset_t block, oblock, pending;
    // 1.1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);
    // 1.2 添加要屏蔽的信号
    for(const auto &sig : sigarr) sigaddset(&block, sig);
    // 1.3 开始屏蔽,设置进内核(进程)
    sigprocmask(SIG_SETMASK, &block, &oblock);

    // 2. 遍历打印pengding信号集
    int cnt = 10;
    while(true)
    {
        // 2.1 初始化
        sigemptyset(&pending);
        // 2.2 获取它
        sigpending(&pending);
        // 2.3 打印它
        show_pending(pending);
        // 3. 慢一点
        sleep(1);
        if(cnt-- == 0)
        {
            sigprocmask(SIG_SETMASK, &oblock, &block); // 一旦对特定信号进行解除屏蔽,一般OS要至少立马递达一个信号!
            cout << "恢复对信号的屏蔽,不屏蔽任何信号\n";
        }
    }
}

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达


用户态:1.操作系统自身的资源(getpid、waitpid)2.硬件资源(printf、write)
用户为了访问内核或者硬件的资源必须通过系统调用完成访问,往往系统调用比较费时间,所以要尽量避免频繁调用系统调用。实际执行系统调用的进程“用户”,但是身份其实是内核。

我是一个进程,怎么跑到OS中执行方法呢?
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

进程通过系统调用接口,系统调用接口会自己将进程的运行级别更改为内核态,这样就有权限去访问内核里面的调用,返回的时候又会由内核态转换为用户态。


信号的捕捉流程

信号产生的时候,不会被立即处理,而是在合适的时候→从内核态返回用户态的时候,那么这样我们一顶是曾经先进入了内核态(系统调用、进程切换)

陷入内核执行自定义信号捕捉方法流程:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
信号捕捉:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

我们能不能以内核态的身份去执行用户态代码?
答案是不能,操作系统无法识别里面的内容是合法还是非法,如果以内核态的身份去执行用户态的代码,很容易这份代码被恶意分子利用,以一个内核态的身份在一定程度的越权去执行非法动作。即便我们技术上可能实现,但是我们也不能这样。

sigaction

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

//函数原型
int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);

struct sigaction {
	void     (*sa_handler)(int);
	void     (*sa_sigaction)(int, siginfo_t *, void *);
	sigset_t   sa_mask;
	int        sa_flags;
	void     (*sa_restorer)(void);
};

用法:

#include <iostream>
#include <signal.h>
#include <unistd.h>
using namespace std;
void handler(int signo)
{
    cout << "get a signo: " << signo << "正在处理中..." << endl;
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask); 
    sigaction(SIGINT, &act, &oact);
    while(true) sleep(1);
    return 0;
}

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

1.小实验:如果进程在处理2号信号,那我们继续发送2号信号会怎么样?

我们对上面的代码做修改:

void Count(int cnt)
{
    while(cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}
void handler(int signo)
{
    cout << "get a signo: " << signo << "正在处理中..." << endl;
    Count(20);
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask); 
    sigaction(SIGINT, &act, &oact);
    while(true) sleep(1);
    return 0;
}

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
输出结果:
我们一次性发了6个kill -2 (pid)但是从一开始到最后,我们最终只运行了两个。

结论:
当我们进行正在递达某一个信号期间,同类型信号无法被递达!当当前信号正在被捕捉系统会自动将当前信号加入到进程的信号屏蔽字block。当信号完成捕捉动作,系统又会自动解除对该信号的屏蔽。

为什么运行了两次?我们在运行时,第一个命令发送2号信号被捕捉,信号在递达前会将pending表置为0,接下来发送相同命令kill -2 (pid)可以,但是都更改的是同一个pending表(将相同表的同一位置反复置1),这也会再运行一次,原因:一般一个信号被解除屏蔽的时候,会自动进行递达当前屏蔽信号,如果该信号已经被pending的话,没有就不做任何动作!

我们进程处理信号的原则是串行的处理同类型的信号,不允许递归

2.如何正在处理这个信号,同时屏蔽其他信号

当我们正在处理某一种信号的时候,我们也想顺便屏蔽其他信号,就可以添加到这个sa_mask中

sigaddset(&act.sa_mask, 3);//3号快捷键是ctrl + \

运行结果:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
当2号信号处理完以后,2号信号与3号信号的屏蔽都会一起解除。当然因为发送了3号信号,它的pending表已经置1,在处理完2号信号后就会执行3号信号。
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

3.观察pending表验证上述

我们将pending表同时打印出来印证上面情况:
将打印pending内容添加在计数函数Count中:

static void show_pending(const sigset_t &pending)
{
    for(int signo = MAX_SIGNUM; signo >= 1; signo--)
    {
        if(sigismember(&pending, signo))
        {
            cout << "1";
        }
        else cout << "0";
    }
    cout << "\n";
}
void Count(int cnt)
{
    while(cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
        
        sigset_t pending;
        // 2.1 初始化
        sigemptyset(&pending);
        // 2.2 获取它
        sigpending(&pending);
        // 2.3 打印它
        show_pending(pending);
        // 3. 慢一点
        sleep(1);
    }
    printf("\n");
}

输出现象:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
我们在捕捉到第一个2号信号并开始执行的时候,此时这个pending表2号位已经置0,我们再次传入kill -2 (pid),这个时候pending表2号位置为1,由于我们在本章第二小点,我们在处理这个信号时,将3号信号屏蔽了,所以我们继续传入kill -3 (pid)并不会终止,而是样将pending表3号位置1。最终运行结果是:等第一个2号信号结束,会继续运行下一个2号信号,等待这个2号信号也结束,才会执行3号信号。


可重入函数

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换到sighandler函数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入操作的两步都做完之后从sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续往下执行,先前做第一步之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后向链表中插入两个节点,而最后只有一个节点真正插入链表中了。

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为不可重入函数,反之,如果一个函数只访问自己的局部变量或参数,则称为可重入(Reentrant)函数。想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

  1. 一般而言,我们认为: main执行流,和信号捕捉执行流是两个执行流!
  2. 如果在main中,和在handler中,该函数被重复进入,出问题–该函数insert不可重入函数
  3. 如果在main中,和在handler中,该函数被重复进入,没有出问题-该函数insert可重入函数

不可重入是问题么?因为如果这是一个问题话,我们需要想办法解决问题,我们目前大部分情况下用的接口,全部都是不可重入的!不可重入不是问题是特性,是一个中性词!

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

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

volatile

volatile:保持内存可见性

我们下执行下面代码:

int quit = 0;
void handler(int signo)
{
    printf("pid: %d, %d 号信号,正在被捕捉!\n", getpid(), signo);
    printf("quit: %d", quit);
    quit = 1;
    printf("-> %d\n", quit);
}
int main()
{
    signal(2, handler);
    while (!quit);
    printf("注意,我是正常退出的! \n");
    return 0;
}

执行结果:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
我们更改一下编译器的优化等级:

gcc -o mysignal  mysignal.c -O3

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
解释图:
一开始:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
更改编译器优化等级
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
为了让内存保持可见性:

volatile int quit = 0;

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

这样quit加上volatile就可以让cpu在执行的时候,与内存时刻保持联系


SIGCHLD信号 - 相关僵尸进程

之前讲过用wait和waitpid函数清理僵尸进程,父进程可以阻塞等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式,父进程阻塞了就不能处理自己的工作了;采用第二种方式,父进程在处理自己的工作的同时还要记得时不时地轮询一下,程序实现复杂。

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

1.验证子进程退出发送退出信号SIGCHLD给父进程

volatile int quit = 0;
void handler(int signo)
{
    printf("pid: %d, %d 号信号,正在被捕捉!\n", getpid(), signo);
    printf("quit: %d", quit);
    quit = 1;
    printf("-> %d\n", quit);
}
void Count(int cnt)
{
    while (cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}
int main()
{
    signal(SIGCHLD, handler);
    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());

    pid_t id = fork();
    if (id == 0)
    {
        printf("我是子进程, %d, ppid: %d,我要退出啦\n", getpid(), getppid());
        Count(5);
        exit(1);
    }
    return 0;
}

我们可以发现,在子进程退出以后,父进程确实收到了退出信号SIGCHLD
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
这个SIGCHLD默认是:
【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达

2.编写一个程序完成以下功能:父进程fork出子进程,子进程调用exit(2)终止,父进程自定义SIGCHLD信号的处理函数,在其中调用wait获得子进程的退出状态并打印。

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)
    { // 子进程
        printf("child : %d\n", getpid());
        sleep(3);
        exit(2);
    }
    while (1)
    {
        printf("father proc is doing some thing! pid:%d\n",getpid());
        sleep(1);
    }
    return 0;
}

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
上面自定义handler的处理方法,回收子进程资源这样写是因为,可能不止一个子进程资源需要回收。如果直接waitpid回收,其他子进程退出后发送相同的退出信号SIGCHLD那么跟之前一样只会处理两次信号,其余的会忽略,这样不是所有的子进程资源都会被回收。

3.验证调用sigaction将SIGCHLD的处理动作置为SIG_IGN不会产生僵尸进程

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

验证上述做不会产生僵尸进程:

void Count(int cnt)
{
    while (cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}
int main()
{
    // 显示的设置对SIGCHLD进行忽略
    signal(SIGCHLD, SIG_IGN);
    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id == 0)
    {
        printf("我是子进程, %d, ppid: %d,我要退出啦\n", getpid(), getppid());
        Count(5);
        exit(1);
    }
    while (1)sleep(1);
    return 0;
}

【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法,Linux基础,linux,运维,服务器,信号保存,信号递达
循环打印进程信息脚本:

while :; do ps axj | head -1 && ps axj | grep mysignal | grep -v grep;sleep 1;echo "--------------"; done

在之前,我们子进程退出后会进入僵尸状态,现在子进程退出后直接被回收,我们都没看到关于子进程的信息了。

显示的设置对SIGCHLD进行忽略,与它本身信号默认处理动作是Ign,所表现出来的动作是不一样的。使用默认的就是之前出现僵尸进程的流程,手动的设置会更改原本的处理动作。这两个区分度是不一样的。


如有错误或者不清楚的地方欢迎私信或者评论指出🚀🚀文章来源地址https://www.toymoban.com/news/detail-594407.html

到了这里,关于【Linux】进程信号 -- 信号保存与递达 | 信号捕捉 | 僵尸进程的信号处理方法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux】进程信号(完整版) --- 信号产生 信号保存 信号捕捉 可重入函数 volatile SIGCHLD信号等

    🍎 作者: 阿润菜菜 📖 专栏: Linux系统编程 我们想要杀死某个后台进程的时候,无法通过ctrl+c热键终止进程时,我们就会通过kill -9的命令来杀死信号。 查看信号也比较简单,通过 kill -l 命令就可以查看所有信号的种类,虽然最大的信号编号是64,但实际上所有信号只有6

    2024年02月04日
    浏览(49)
  • [Linux打怪升级之路]-信号的保存和递达

    前言 作者 : 小蜗牛向前冲 名言 : 我可以接受失败,但我不能接受放弃    如果觉的博主的文章还不错的话,还请 点赞,收藏,关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正 目录 一、信号的保存  1、信号其他相关常见概念 2、信号在内核中的表示 3、

    2024年02月05日
    浏览(39)
  • Linux系统调用之signal,sigaction函数 (捕捉指定的信号,自定义/默认处理该信号)

    如果,想要深入的学习Linux系统调用中的signal,sigaction函数,还是需要去自己阅读Linux系统中的帮助文档。 具体输入命令: 即可查阅到完整的资料信息。 signal()是一个用于处理Unix和类Unix操作系统(如Linux)中的信号的系统调用。信号是用于在进程间或者进程内部传递通知或者

    2024年02月02日
    浏览(44)
  • 【linux】信号——信号保存+信号处理

    自我名言 : 只有努力,才能追逐梦想,只有努力,才不会欺骗自己。 喜欢的点赞,收藏,关注一下把! 上一篇博客,我们已经学过信号预备知识和信号的产生,今天讲讲信号保存+信号处理以及其他补充知识。 补充一些概念。 实际执行信号的处理动作称为 信号递达(Delive

    2024年02月04日
    浏览(40)
  • 【Linux】 信号的保存 | 捕捉

    对于信号,主要涉及到信号的产生、保存和捕获,之前谈到了信号的产生,这里主要介绍信号产生后如何进行保存和捕捉处理的原理。 相关概念 实际执行处理信号的动作称为 信号递达Delivery 信号从产生到递达的过程称为 信号未决Pending 进程可以阻塞、忽略某个信号。 被阻塞

    2024年02月21日
    浏览(36)
  • 【Linux】信号的保存和捕捉

    我们知道,操作系统是进程的管理者,只有操作系统才有资格向进程发信号,具体点,是给进程的PCB发信号。 更具体点,就是将进程的task_struct中的signal整形的某一个比特位由0置1!!! 那么该信号如何被保存下来呢? 实际执行信号的处理动作称为信号递达(Delivery) 信号从产

    2024年02月05日
    浏览(34)
  • 【Linux从入门到精通】信号(信号保存 & 信号的处理)

      本篇文章接着信号(初识信号 信号的产生)进行讲解。学完信号的产生后,我们也了解了信号的一些结论。同时还留下了很多疑问: 上篇文章所说的所有信号产生,最终都要有OS来进行执行,为什么呢? OS是进程的管理者 。 信号的处理是否是立即处理的? 在合适的时候。

    2024年02月09日
    浏览(41)
  • 【Linux】进程信号——进程信号的概念和介绍、产生信号、四种产生信号方式、阻塞信号、捕捉信号、阻塞和捕捉信号的函数

      在Linux中,进程信号是一种异步的事件通知机制,用于通知进程某个事件已经发生。它是进程间通信的一种方式,可以用来控制进程的行为。   当一个进程收到信号时,操作系统会中断该进程的正常控制流程,并执行相应的处理函数。进程收到信号后有三种处理方式:

    2024年02月02日
    浏览(55)
  • Linux进程信号【信号处理】

    ✨个人主页: 北 海 🎉所属专栏: Linux学习之旅 🎃操作环境: CentOS 7.6 阿里云远程服务器 从信号产生到信号保存,中间经历了很多,当操作系统准备对信号进行处理时,还需要判断时机是否 “合适”,在绝大多数情况下,只有在 “合适” 的时机才能处理信号,即调用信号

    2024年02月11日
    浏览(39)
  • Linux进程信号 | 信号处理

    前面的文章中我们讲述了信号的产生与信号的保存这两个知识点,在本文中我们将继续讲述与信号处理有关的信息。 之前我们说过在收到一个信号的时候,这个信号不是立即处理的,而是要得到的一定的时间。从信号的保存中我们可以知道如果一个信号之前被block,当解除

    2024年02月09日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包