[Linux]-----进程信号

最新推荐文章于 2024-01-19 17:55:16 发布
最新推荐文章于 2024-01-19 17:55:16 发布
阅读量747 收藏 1
点赞数 4
文章标签： linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61560468/article/details/128001938
版权

文章目录

前言

正文开始！

一、什么是信号

生活中的信号有哪些呢？

红绿灯，下课铃声，信号枪，烽火台，旗语…

我们是如何得知这些信号呢？

别人教(能够认识这些场景下的信号以及所表示的含义)

我们知道对应的信号产生时，要做什么呢？

我早就知道了信号产生之后我们要做什么！即便当前信号还没有产生！—>我们提前已经知道了这个信号的处理方法！

即便这个信号还没产生，我们已经拥有处理信号的能力！

二、进程信号

信号是给进程发送的，进程要具备处理信号的能力！

  1. 该能力一定是预先已经拥有的。
  2. 进程能够识别对应的信号。
  3. 进程能够处理对应的信号。

进程处理信号的能力是程序员给予的！OS帮我们提供！
对于进程来讲，即便这个信号还没产生，我们进程已经具有识别和处理这个信号的能力！

前台进程和后台进程

在这里插入图片描述
前台进程运行的时候你输入其他的命令Bash是无法给你做出响应的！

./程序名 &

以后台进程去运行，你输入其他的命令是可以继续执行的！
但是打出来的东西很乱！

在这里插入图片描述
那么如何终止这个进程呢？

jobs

查看后台进程任务编号就是1
在这里插入图片描述
将该进程提至前台运行

fg(front ground) 编号

在这里插入图片描述
然后Ctrl+c终止进程即可！

让进城在放置后台运行

bg 编号

注意

  1. Ctrl+C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
  2. Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生的信号。
  3. 前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步(Asynchronous)的。

三、信号列表

用kill -l命令可以察看系统定义的信号列表
在这里插入图片描述

每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定 义 #define SIGINT 2

Linux下一共有62个信号！
Linux下的信号被分为了两批

  1. 1-31(普通信号)—>常用的信号
  2. 34-64(实时信号)—>常用于实时操作系统！

我们常用的计算机都是分时操作系统，所以就着重带大家了解前31个信号即可！

因为信号产生时是异步的，当信号产生的时候，对应的进程可能正在做更重要的事情，我们进程可以暂时不处理这个信号！

所以进程可能不需要立即处理这个信号！—>不代表这个信号不会处理！

但是必须记住这个信号已经来了(有信号来了吗？什么信号？)

信号的捕捉

  1. 默认动作
  2. 忽略信号
  3. 自定义动作

进程是如何记住这个信号的，在哪呢？

保存在进程的PCB中的！！

tash_struct{
	uint_32 sig;//位图结构，每一位代表一个信号，1表示发生
};
task_strcut是内核的数据结构！--->所以只有操作系统有权利修改task_struct内的数据位图！！
OS是进程的管理者，进程的所有属性的获取和设置，只能由OS来！-->无论信号怎么产生，最终一定是OS帮我们进行信号的设置的！！！

有没有产生？[bit位的内容]
什么信号产生?[bit位的位置]

举个栗子：0000 0010 就代表有信号产生，是二号信号！（默认从右往左数）

四、信号产生前

用户层产生信号的方式

  1. 键盘产生
    谁给进程发送的信号呢？—> 只能是操作系统—>更改PCB中的位图结构，该信号比特位由0置1

  2. 通过系统接口完成对进城发送信号的过程

  3. 由软件条件产生信号

  4. 硬件异常产生信号

signal函数

·

#include <iostream>
#include <string>
#include <stdlib.h>
#include <cstring>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;
void handler(int signo)
{
    cout << "我是一个进程，刚刚获取了一个信号： " << signo << endl;
    cout << cnt << endl;
}
int main()
{
    //这里不是调用hander的方法，这里只是设置了一个回调，让SIGINT(2)产生的时候，刚方法才会被调用
    //如果不产生SIGINT,该方法不会被调用！
    // ctrl + c :本质就是给前台进程产生了2号信号，发送给目标进程，目标进程默认对2号信号的处理是终止自己
    //我们更改了对二号信号的处理，设置了用户自定义处理方法
    signal(SIGINT, handler);
    sleep(3);
    cout << "进程已经设置完了！" << endl;
    while (true)
    {
        cout << "我是一个正在运行中的进程: " << getpid() << endl;
        sleep(1);
    }
    return 0;
}

在这里插入图片描述

给上面代码设置3号信号的捕捉动作

signal(3, handler);

在这里插入图片描述

Ctrl+\是发送三号信号

注意：九号信号就算设置了默认处理函数，也照样可以杀掉该进程！

kill

在这里插入图片描述

自己实现kill命令

#include <iostream>
#include <string>
#include <stdlib.h>
#include <cstring>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

static void Usage(const std::string &proc)
{
    cerr << "Usage:\n\t" << proc << " signo pid" << endl;
}
//我想写一个kill命令
// mykill 9 1234
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    if (kill(static_cast<pid_t>(atoi(argv[2])), atoi(argv[1])) == -1)
    {
        cerr << "kill" << strerror(errno) << endl;
    }
    return 0;
}

在这里插入图片描述
在这里插入图片描述

raise

在这里插入图片描述

int main(int argc, char *argv[])
{
    signal(2, handler); //没有调用对应的handler方法，仅仅是注册
    while (1)
    {
        sleep(1);
        raise(2);
    }
    return 0;
}

在这里插入图片描述

abort

在这里插入图片描述
发送的信号是SIGABRT信号

在这里插入图片描述
我们把SIGABRT设为默认处理会怎么样呢？

int main(int argc, char *argv[])
{
    signal(SIGABRT, handler); //没有调用对应的handler方法，仅仅是注册
    while (1)
    {
        sleep(1);
        abort();
    }
    return 0;
}

在这里插入图片描述
所以六号信号是可以被捕捉的，但是还是要终止掉进程的！！！

由软件条件产生信号

在这里插入图片描述

调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

int main(int argc, char *argv[])
{
    alarm(1);
    for(;;)
    {
        //是谁在推动操作系统做一系列的动作呢？
        //硬件---时钟硬件--给OS发送时钟中断
        printf("hello : %d\n",cnt++);//统计一个我们的进程1S cnt++多少次
    }
    return 0;
}

在这里插入图片描述

统计一个我们的进程1s会把cnt++多少次！

硬件异常产生信号

int main(int argc, char *argv[])
{
    int a=1;
    a/=0;
    return 0;
}

在这里插入图片描述
除零:CPU内部有一个状态寄存器，
当我们除零的时候，CPU内的状态寄存器会被设置成为，有报错:浮点数越界
CPU的内部寄存器(硬件)，OS就会识别到CPU内有报错啦–>1.谁干的？
2.是什么报错？
(OS–>构建信号)—>目标进程发送信号–>目标进程在合适的时候–>终止进程

int main(int argc, char *argv[])
{
    int* p=nullptr;
    *p=1;
    return 0;
}

在这里插入图片描述
越界&&野指针:我们在语言层面上使用的地址(指针),
其实都是虚拟地址—>物理地址—>物理内存–>读取对应的数据和代码的
如果虚拟地址有问题，地址转化的工作是由(MMU(硬件)+页表(软件))，转化过程就会引起问题，表现在硬件MMU上—>OS发现硬件出现了问题

进程崩溃的本质是该进程收到了异常的信号！

为什么呢？

因为硬件异常，而导致OS向目标进程发送信号，进而导致进程终止的现象！

崩溃了，一定会导致进程终止吗？？—>不一定！！

int main(int argc, char *argv[])
{   
    signal(3,handler);
    for(int i=1;i<32;i++)
    {
        signal(i,handler);
    }
    sleep(3);
    cout<<"进程已经设置完了！"<<endl;
    int a=10;
    a/=0;
    return 0;
}

在这里插入图片描述

总结

  • 上面所说的所有信号的产生，最终都要有OS来进行执行，为什么？—>OS是进程的管理者！
  • 信号的处理是否是被立即处理的？–>在合适的时候
  • 信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？
  • 一个进程在没有收到信号的时候，能否知道，自己应该对合法信号作何处理呢？
  • 如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？

core dump字段

这是在我带大家了解进程控制时留的小尾巴，因为当时没有办法去讲！
[ Linux ] 进程控制(下)----进程等待与进程程序替换

在这里插入图片描述

int main(int argc, char *argv[])
{   
    pid_t id=fork();
    if(id==0)
    {
        //子进程
        int* p=nullptr;
        *p=10;//野指针问题
        exit(1);
    }
    //父进程
    int status=0;
    waitpid(id,&status,0);
    printf("exit code: %d,signo: %d,core dump flag: %d\n",
    (status>>8)&0xff,status&0x7f,(status>>7)&0x1);
    return 0;
}

在这里插入图片描述

man 7 signal

在这里插入图片描述我们可以看到不同的信号有不同的Action，有的是Term直接终止了。。。。
那么Core是什么呢？

ulimit -a

在这里插入图片描述
线上生产中，core字段默认是0，也就是关闭的！
打开

ulimit -c 100000

在这里插入图片描述
打开core字段后，我们发现core dump标记位直接被设置为1了

并且还多了core.28389这个大文件

28389就是我们引起进程发生错误的id号！

在这里插入图片描述
core dump会把进程在运行中，对应得异常上下文数据，core dump到磁盘上，方便调试的！—>并且将status中的core dump标记位置为1！
在这里插入图片描述
然后我们进行gdb调试，运行该文件，我们就直接定位到出现异常的那一行了！！！

但是，core dump位一般是关闭的，因为他所占内存大小太大了！

五、信号产生中

阻塞信号

1.信号其他相关常见概念

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

2. 在内核中的表示

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

在这里插入图片描述

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

3.sigset_t

从上图来看，每个信号只有一个bit的未决标志，非0即1，不记录该信号产生了多少次，阻塞标志也是这样表示的。因此，未决和阻塞可以使用想的数据类型sigset_t来存储，sigset_t称为信号集，这个类型可以表示每个信号的"有效"和"无效"的含义是该信号是否被阻塞，而在未决信号集中"有效"和"无效"
的含义是该信号是否处于未决状态。稍后我来带大家了解信号集的各种操作。阻塞信号集也叫作当前进程的信号屏蔽字(Signal Mask)，这里的"屏蔽"应该理解为阻塞而不是忽略。

4.信号集操作函数

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 sigismember(const sigset_t *set, int signo);
  • 函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号。
  • 函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系统支持的所有信号。
  • 注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信。

函数的使用

static void showPending(sigset_t *pendings)
{
    for (int sig = 1; sig < 32; sig++)
    {
        if (sigismember(pendings, sig))
        {
            cout << '1';
        }
        else
            cout << '0';
    }
    cout << endl;
}
int main(int argc, char *argv[])
{   
    sigset_t bsig,obsig;
    sigemptyset(&bsig);
    sigemptyset(&obsig);
    for(int sig=1;sig<=31;sig++)
    {
        //2.给2号信号设置自定义选项
        signal(sig,handler);
        //3.屏蔽二号信号

        //3.1添加二号信号到信号屏蔽字中
        sigaddset(&bsig,sig);
    }
    //3.2设置用户级的信号屏蔽字到内核中，让当前进程屏蔽到二号信号
    sigprocmask(SIG_SETMASK,&bsig,&obsig);

    //1.不断的获取当前进程的pending信号集
    sigset_t pendings;
    int cnt=0;
    while(true)
    {
        //1.1清空信号集
        sigemptyset(&pendings);
        //1.2获取当前进程(谁调用，获取谁)的pendings信号集
        if(sigpending(&pendings)==0)
        {
            showPending(&pendings);
        }
        sleep(1);
    }
    return 0;
}

在这里插入图片描述
在这里插入图片描述
while(true)中加入部分代码

while(true)
    {
        //1.1清空信号集
        sigemptyset(&pendings);
        //1.2获取当前进程(谁调用，获取谁)的pendings信号集
        if(sigpending(&pendings)==0)
        {
            showPending(&pendings);
        }
        sleep(1);
        cnt++;
        if(cnt==10)
        {
            cout<<"解除对所有信号的block "<<endl;
            sigprocmask(SIG_SETMASK,&obsig,nullptr);
        }
    }

在这里插入图片描述

信号的捕捉

进程处理信号，不是理解处理的。—>在合适的时候！---->是什么时候呢？

当当前进程从内核态，切换回用户态的时候，进行信号的检测与处理！
在这里插入图片描述

六、信号处理后

在这里插入图片描述
在这里插入图片描述

进程的信号在被合适的时候处理----从内核态返回到用户态的时候—>检测----处理

  1. 如何理解内核态和用户态

  2. 进程的生命周期中，会有很多次机会去陷入内核(中断，陷阱，系统调用，异常…)，一定会存在很多次的机会进行内核态返回用户态！

对信号处理使用自定义方法，我们执行的是用户代码！！！只能用用户态的身份去执行的！—>因为这部分代码是用户写的！！—>如果写的是一段恶意的代码呢！！！

signaction

在这里插入图片描述


#include <iostream>
#include <signal.h>
#include <unistd.h>
using namespace std;

void handler(int signo)
{
    cout << "获取到一个信号，信号的编号是: " << signo << endl;
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;//自定义方法
    // act.sa_handler=SIG_IGN;//忽略方法
    // act.sa_handler=SIG_DFL;//默认处理方法
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(2, &act, &oact);
    while (true)
    {
        cout << "main running" << endl;
        sleep(1);
    }
    return 0;
}

当某个信号的处理函数被调用的时候，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，如果这种信号再次产生，那么他会被阻塞到当前处理结束为止。如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时自动恢复原来的信号屏蔽字。sa_flags字段包含一些选项，本章的代码都把sa_flags设为0，sa_sigaction是实时信号的处理函数，此处我们不做研究！

void handler(int signo)
{
    cout << "获取到一个信号，信号的编号是: " << signo << endl;
    sigset_t pending;
    //增加handler信号的处理时间,永远都会在处理二号信号
    while (true)
    {
        sigpending(&pending);
        for (int i = 1; i <= 31; i++)
        {
            if (sigismember(&pending, i))
                cout << "1";
            else
                cout << "0";
        }
        cout << endl;
        sleep(1);
    }
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;//自定义方法
    // act.sa_handler=SIG_IGN;//忽略方法
    // act.sa_handler=SIG_DFL;//默认处理方法
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(2, &act, &oact);
    while (true)
    {
        cout << "main running" << endl;
        sleep(1);
    }
    return 0;
}

在这里插入图片描述

总结

（本章完！）

拾至灬名瑰
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
Linux-进程间通信
10-07
****Linux****-进程间通信-每块都是概括 管道-消息队列-信号量-共享内存-套接字-信号
Linux信号列表
Xianfeng Design
05-22 1103
我们运行如下命令，可看到Linux支持的信号列表：$ kill -l1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 1
_016_信号
weixin_30569033的博客
06-12 176
============================================ 信号的概念 　　 　　 常用31种信号 　　摘自:https://www.cnblogs.com/niupan369/p/4119607.html 1) SIGHUP 本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各...
Linux中的信号
m0_55752775的博客
05-28 2723
信号是如何产生的？操作系统是如何处理信号的？
Linux信号一览
lqc132的博客
11-11 1796
默认动作: Term:终止进程。 lgn:忽略信号(默认即时对该种信号忽略操作)。 Core:终止进程，生成Core文件。(查验进程死亡原因，用于gdb调试) Stop:停止(暂停)进程。 Cont:继续运行进程。 注意从man 7 signal帮助文档中可看到: The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored. 这里特别强调了9) SIGKILL和19) SIGSTOP信号，不允许忽略和捕捉，只能执行默认动作..
Linux信号详解
普通大学生的博客
03-10 746
你在网上买了很多件商品，再等待不同商品快递的到来。但即便快递没有到来，你也知道快递来临时，你该怎么处理快递。也就是你能“识别快递”。当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需5min之后才能去取快递。那么在在这5min之内，你并没有下去去取快递，但是你是知道有快递到来了。也就是取快递的行为并不是一定要立即执行，可以理解成“在合适的时候去取"。在收到通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间，你并没有拿到快递，但是你知道有一个快递已经来了。
Linux进程间通信--使用信号
09-15
本篇文章主要介绍了Linux进程间通信--使用信号的相关知识。具有很好的参考价值。下面跟着小编一起来看下吧
Linux-C编程API函数(掌握这些足够).pdf
06-02
linux下C编程各种API接口，查找非常方便，并且还有实例，我也是借花谢佛，不知道是哪位大佬整理的，这么好的资源应该跟大家一起分享！ 1 字符测试篇 2 字符串转换篇 3 内存控制篇 4 日期时间篇 5 内存及字符...
linux编程参考-进程和信号
11-23
linux编程参考-进程和信号的问题的解决，解决操作系统进程学习期间遇到的问题
Linux-C编程常用API接口-函数
07-18
linux中常用API详细介绍，包含应用例程 1 字符测试篇 2 2 字符串转换篇 10 3 内存控制篇 17 4 日期时间篇 22 5 内存及字符串操作篇 28 6 常用数学函数篇 45 7 用户组篇 56 8 数据结构及算法篇 78 9 文件操作篇 85 10...
linux信号详细列表
08-24
1 ~ 31的信号解释
linux常用信号列表
ZD的博客
04-26 4327
SIGHUP：本信号在用户终端结束时发出，通常是在终端的控制进程结束时，通知同一会话期内的各个作业，这时他们与控制终端不在关联。比如，登录linux时，系统会自动分配给登录用户一个控制终端，在这个终端运行的所有程序，包括前台和后台进程组，一般都属于同一个会话。当用户退出时，所有进程组都将收到该信号，这个信号的默认操作是终止进程。此外对于与终端脱离关系的守护进程，这个信号用于通知它重新读取配置文件。
Linux signal小结
最新发布
$好记性还是要多记录$
01-19 806
linux signal详解
linux 详细信号列表及Linux信号和信号集
weixin_34259232的博客
08-31 443
SIGHUP 终止进程 终端线路挂断[喝小酒的网摘]http://blog.hehehehehe.cn/a/16999.htmSIGINT 终止进程 中断进程SIGQUIT 建立CORE文件终止进程，并且生成core文件SIGILL 建立CORE文件 非法指令SIGTRAP 建立CORE文件 跟踪自陷SIGB...
Linux下的各种信号
qq_53395528的博客
08-16 690
（31）：错误的系统调用信号，在进程执行错误的系统调用时产生。（24）：超出 CPU 时间限制信号，在进程超出 CPU 时间限制时产生。（5）：跟踪/断点陷阱信号，当进程执行单步调试或遇到断点时产生。（21）：后台读取终端信号，在后台进程从控制终端读取数据时产生。（22）：后台写入终端信号，在后台进程向控制终端写入数据时产生。（25）：超出文件大小限制信号，在进程超出文件大小限制时产生。（7）：总线错误信号，当进程访问无效内存地址时产生。（8）：浮点异常信号，当进程执行浮点运算错误时产生。
Linux 操作系统 019-常用信号
Tianwx的博客
01-05 586
本节关键字：Linux、centos、常用信号 本节相关指令：uname、kill、signal
linux 目录说明
weixin_43884350的博客
08-29 196
项目 价格 /bin 存放二进制可执行文件(ls,cat,mkdir等)，常用命令一般都在这里 /etc 存放系统管理和配置文件 /home 存放所有用户文件的根目录，是用户主目录的基点，比如用户user的主目录就是 /usr 1、用于存放系统应用程序，比较重要的目录/usr/local 本地系统管理员软件安装目录（安装系统级的应用）。这是最庞大的目录，要用到的应用程序...
Linux操作系统信号
写博客记录分享学习笔记
02-13 378
本文介绍了Linux操作系统中关于进程信号的概念，主要根据信号产生、信号阻塞、信号捕捉这三个方面进行介绍。
linux系统-进程间通信
07-27
\[1\]\[2\]常见的进程间通信方式包括共享内存、管道、消息队列和信号量等。\[2\]在实现进程间通信时，需要关闭对应的文件描述符，子进程关闭读端，父进程关闭写端，然后通过读写操作进行数据的传输。\[3\]通过这种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拾至灬名瑰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值