linux进程间通讯-信号

最新推荐文章于 2023-11-01 19:32:03 发布
最新推荐文章于 2023-11-01 19:32:03 发布
阅读量316 收藏 3
点赞数
分类专栏： linux系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44681745/article/details/116173319
版权

文章目录

进程间通信功能

数据传输：一个进程需要将它的数据发送给另一个进程。
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程 希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。
Linux操作系统支持的主要进程间通信的通信机制
在这里插入图片描述
进程间通信的实质

系统只要创建一个进程，就会给当前进程分配4G的虚拟内存（32位操作系统），虚
拟内存 不是常说的内存条的空间，内存条的空间称之为物理内存，虚拟内存和物理
内存之间存在映 射关系 4G的虚拟内存分为3G的用户空间（0~3G）和1G（3~4G）
的内核空间， 用户空间是进程所私有的，每一个进程的用户空间只能自己访问和使用，我们之前说的栈区、堆区、数据区、代码区等都是用户空间的区域.内核空间是所有进程
所公有的，也就意味着绝大多数进程间通信方式，本质就是对内核空间的操作。

特殊的进程间通信方式

socket通信可以实现不同主机的进程间通信，其他六个只能在一台主机的多个进程
间通信，信号通信是唯一的一种异步通信机制 共享内存是所有进程间通信方式中效
率最高的，他是直接对物理内存进行操作。

信号

信号的概念

信号是软件中断，它是在软件层次上对中断机制的一种模拟。
信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个 突发事件。 信号是一种异步通信方式。
每个信号的名字都以字符SIG开头。
每个信号和一个数字编码相对应，在头文件signum.h中，这些信号都被定义为正整数。
在Linux下，要想查看这些信号和编码的对应关系，可使用命令：kill -­l。
信号是由当前系统已经定义好的一些标识，每一个标识都会在特定的场合使用，并且都会对进程有一定的影响。
当信号产生时，会让当前信号做出相应的操作这些信号都是已经定义好的，我们不能自己再去创造，直接使用这些就可以。

产生信号的方式

1、当用户按某些终端键时，将产生信号 
例如：终端上按“Ctrl+c”组合键通常产生中断信号SIGINT、 
终端上按"Ctrl+\"键通常产生中断信号SIGQUIT、 
终端上按"Ctrl+z"键通常产生中断信号SIGSTOP。 
2、硬件异常将产生信号 除数为0，无效的内存访问等。这些情况通常由硬件检测到
，并通知内核,然后内核产生 适当的信号发送给相应的进程。
3、软件异常将产生信号。 当检测到某种软件条件已发生，并将其通知有关进程时，
产生信号。 
4、调用kill函数将发送信号。 注意：接收信号进程和发送信号进程的所有者必须相
同，或发送信号进程的所有者必 须是超级用户。 
5、运行kill命令将发送信号。 此程序实际上是使用kill函数来发送信号。也常用此命
令终止一个失控的后台进程。

信号的默认（缺省）处理方式

当进程中产生了一个信号，就会让当前进程做出一定的反应， 默认处理进程的方式
如下 
1、终止进程：当信号产生后，当前进程就会立即结束 
2、缺省处理：当信号产生后，当前进程不做任何处理 
3、停止进程：当信号产生后，使得当前进程停止 
4、让停止的进程回复运行：当信号产生后，停止的进程会回复执行（后台进程）

进程接收到信号后的处理方式

1、执行系统默认动作 对大多数信号来说，系统默认动作是用来终止该进程。 
2、忽略此信号 接收到此信号后没有任何动作。 
3、执行自定义信号处理函数 用用户定义的信号处理函数处理该信号。 
注意：SIGKILL和SIGSTOP这两个信号只能以默认的处理方式执行，不能忽略也不
能自定义。

在这里插入图片描述

kill函数

在这里插入图片描述
例子
使用kill给父进程发送信号，然后父进程接收到信号后直接退出。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
int main(int argc, char *argv[])
{
    pid_t pid;
    pid = fork();
    if(pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if(pid > 0) //父进程的代码区
    {
        while(1)
        {
            printf("This is parent peocess\n");
            sleep(1);
        }
    }
    else //子进程的代码区 
    {
        printf("This is son process\n");
        //子进程在3秒之后，让父进程退出
        sleep(3);
        //使用kill给父进程发送信号，然后父进程接收到信号后直接退出就可以了
        kill(getppid(), SIGINT);

    }
	return 0;
}

在这里插入图片描述

alarm函数

在这里插入图片描述
例子
如果一个程序中出现多个alarm闹钟，第一个如果没有到达指定的时间就遇到第二个。则第一个的闹钟时间清除，按照第二个alarm闹钟的时间继续向下运行。

#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
    unsigned int sec;
    //当执行到alarm之后，代码会接着往下执行，当设定的时间到后，会产生SIGALRM信号
    //如果alarm之前没有设置其他闹钟，则返回0，如果之前设置了，则返回之前剩余的秒数
    //如果一个程序中出现多个alarm闹钟，第一个如果没有到达指定的时间就遇到第二个
    //则第一个的闹钟时间清除，按照第二个alarm闹钟的时间继续向下运行
    sec = alarm(5);
    printf("sec = %d\n", sec);
    sleep(3);
    sec = alarm(6);
    printf("sec = %d\n", sec);
    while(1)
    {
        printf("hello world\n");
        sleep(1);
    }
	return 0;
}

在这里插入图片描述

raise函数

在这里插入图片描述
例子

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
int main(int argc, char const *argv[])
{
    int num = 0;
    while(1)
    {
        printf("hello world\n");
        sleep(1);
        num++;
        //当循环执行5秒后，进程退出
        if(num == 5)
        {
            //使用raise给当前进程本身发送信号
            raise(SIGALRM);
            //kill(getpid(), SIGALRM);
        }
    }
    return 0;
}

在这里插入图片描述

abort函数

在这里插入图片描述
注意：即使SIGABRT信号被加入阻塞集，一旦进程调用了abort函数，进程也还是会被终止， 且在终止前会刷新缓冲区，关闭文件描述符。
例子

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
int main(int argc, char const *argv[])
{
    int num = 0;
    while(1)
    {
        printf("hello world\n");
        sleep(1);
        num++;
        //当循环执行5秒后，进程退出
        if(num == 5)
        {
            abort();
        }
    }
    return 0;
}

在这里插入图片描述

pause函数

在这里插入图片描述
例子

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
int main(int argc, char *argv[])
{
    pid_t pid;
    pid = fork();
    if(pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if(pid > 0) //父进程的代码区
    {
        printf("This is parent peocess\n");
        //使用pause阻塞等待捕捉信号
        pause();
    }
    else //子进程的代码区 
    {
        printf("This is son process\n");
        sleep(3);
        kill(getppid(), SIGINT);
    }
	return 0;
}

在这里插入图片描述

signal函数

在这里插入图片描述

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
void handler(int sig);
int main(int argc, char const *argv[])
{
    //以默认的方式处理信号
#if 0
    if(signal(SIGINT, SIG_DFL) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    if(signal(SIGQUIT, SIG_DFL) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    if(signal(SIGTSTP, SIG_DFL) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
#endif
    //以忽略的方式来处理信号
#if 0
    if(signal(SIGINT, SIG_IGN) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    if(signal(SIGQUIT, SIG_IGN) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    if(signal(SIGTSTP, SIG_IGN) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    //注意：SIGKILL和SIGSTOP这两个信号只能以默认的方式处理，不能忽略或者捕捉
    // if(signal(SIGKILL, SIG_IGN) == SIG_ERR)
    // {
    //     perror("fail to signal");
    //     exit(1);
    // }
#endif    
    //以用户自定义方式处理信号
#if 1
    if(signal(SIGINT, handler) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    if(signal(SIGQUIT, handler) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    if(signal(SIGTSTP, handler) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
#endif  
    while(1)
    {
        printf("hello world\n");
        sleep(1);
    }
    return 0;
}
void handler(int sig)
{
    if(sig == SIGINT)
    {
        printf("SIGINT正在处理\n");
    }
    if(sig == SIGQUIT)
   	{
        printf("SIGQUIT正在处理\n");
    }
    if(sig == SIGTSTP)
    {
        printf("SIGTSTP正在处理\n");
    }
}

查看pid号 ps -aux|grep a.out
Kill -9 加上进程ID号 用来杀死进程。
signal函数的返回值

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
void *ret_handler;
void handler(int sig)
{
    printf("**********************\n");
    printf("nihao beijing\n");
    printf("welcome to 1000phone\n");
    printf("**********************\n");
    if(signal(SIGINT, ret_handler) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
}
int main(int argc, char const *argv[])
{
    if((ret_handler = signal(SIGINT, handler)) == SIG_ERR)
    {
        perror("fail to signal");
        exit(1);
    }
    while(1)
    {
        printf("hello world\n");
        sleep(1);
    }
    return 0;
}

在这里插入图片描述

可重入函数

可重入函数是指函数可以由多个任务并发使用，而不必担心数据错误 可重入函数就是可以被中断的函数，当前函数可以在任何时刻中断它，并执行另一块代码， 当执行完毕后，回到原本的代码还可以正常继续运行。
编写可重入函数：
1、不使用（返回）静态的数据、全局变量（除非用信号量互斥）。
2、不调用动态内存分配、释放的函数。
3、不调用任何不可重入的函数（如标准I/O函数）。
注：
即使信号处理函数使用的都是可重入函数（常见的可重入函数），也要注意进入处理函数时，首先要保存errno的值，结束时，再恢复原值。因为信号处理过程中，errno值随 时可能被改变。
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
void handler(int sig)
{
    printf("SIGINT\n");
}
int main(int argc, char *argv[])
{
    signal(SIGINT, handler);
    //案例1：
#if 0
    //sleep是一个可重入函数，但是当执行信号处理函数之后，不会回到原本的位置继续睡眠
    //sleep(10);
    //alarm函数是一个可重入函数，当他执行时，如果有信号产生并执行信号处理函数，执行完毕后，会继续运行
    alarm(10);
    while(1)
    {
        printf("hello world\n");
        sleep(1);
    }
#endif
    //案例2：
#if 1
    char buf[32] = "";
    //read也是一个可重入函数，在等待终端输入时，如果产生信号并执行信号处理函数，信号处理
    //函数执行完毕后，可以继续输入数据，read可以读取到信号处理函数之后的数据
    if(read(0, buf, 20) == -1)
    {
        perror("fail to read");
        exit(1);
    }
    printf("buf = [%s]\n", buf);
#endif  
	return 0;
}

在这里插入图片描述

兔子警官QAQ
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux进程间通讯
05-02
linux进程间通信方式--管道、信号量、消息队列、共享内存的介绍，以及与这些方式相关的函数讲解。
[Linux]-进程间通信之信号
levi的博客
06-24 279
信号是Linux通信中最古老的通信方法。信号是软件中断，是在软件层次上对中断的一种模拟是一种异步通信（不用死循环等待）的方式。信号可以导致一个正在运行中的异步进程中断，转而处理另一个突发事件。信号主要用来杀死进程（大部分），如果有时候在另一个终端想要退出进程，就是通过发送信号来终止进程。信号具有以下特点：简单、不能携带大量的信息、满足条件发出一个完整的信号周期分为三个部分信号的产生信号在进程中的注册（一般注册自定义函数，注册信号行为）信号在进程中的注销执行信号处理函数。
Linux之进程间通信①——信号（Signal）
夹心狗勾的博客
03-10 543
Linux进程间通信信号篇
【Linux】进程间通信——信号
sinat_41752325的博客
09-28 1069
信号实现进程间通信
Linux进程间通信：信号(signal)
m0_74985965的博客
01-27 1588
在Linux中，①信号可以简单理解为软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。②信号也是进程间通信的一种方式，也是如此，进程才能收到信号指令，完成操作。:查询系统中的信号。
【Linux系统】Linux进程信号详解
fufufu_的博客
05-17 991
在计算机科学中，信号是Unix、类Unix以及其他POSIX兼容的操作系统中进程间通讯的一种有限制的方式。它是一种异步的通知机制，用来提醒进程一个事件已经发生。当一个信号发送给一个进程，操作系统中断了进程正常的控制流程，此时，任何非原子操作都将被中断。如果进程定义了信号的处理函数，那么它将被执行，否则就执行默认的处理函数。在Linux中使用 kill -l 命令来查看信号类型在上图中，1-31的信号为分时信号，34-64为实时信号。本篇文章过多不讨论实时信号。
浅谈Linux进程间通信方式及优缺点
01-11
无名管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用.进程的亲缘关系一般指的是父子关系。无明管道一般用于两个不同进程之间的通信。当一个进程创建了一个管道,并调用fork创建自己...
Linux进程间通讯
02-02
IPC基本概念，无名管道(pipe)概念与编程，有名管道(fifo)概念与编程，信号概念与编程，定时器
php进程间通讯实例分析
10-21
主要介绍了php进程间通讯的方法,结合实例形式分析了php基于unix/linux平台的信号量机制实现进程间通讯的相关技巧,需要的朋友可以参考下
嵌入式系统/ARM技术中的进程间通讯之信号
11-09
　UNIX上进程间通信的方式有多种，早期的有无名管道、有名管道和信号，后来又引入了IPC对象和套接字。信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。信号可以直接进行用户空间进程和内核进程之间的...
Linux进程间通信之信号
最新发布
qq_65360223的博客
11-01 43
Linux进程间通信之信号的相关概念
Linux进程间通信---信号
weixin_58389786的博客
08-16 759
信号集是一个能表示多个信号的数据类型，sigset_t set，set即一个信号集。既然是一个集合，就需要对集合进行添加/删除等操作。//将set集合置空//将所有信号加入set集合//将signo信号加入到set集合//从set集合中移除signo信号//判断信号是否存在int main(){int ret=0;//清空信号集//判断sigint是否在信号集中{}{}{printf("已删除sigint\n");}return 0;}...
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
Linux进程间通信 - 信号(signal) 与 管道(pipe) 与 消息队列
cpp_learner的博客
04-30 1518
详细介绍 信号 与 管道 与 消息队列 与 信号量 的用法！
Linux进程通信之进程信号
m0_60010936的博客
12-06 931
的
Unix高级编程：环境变量(续)、管道、文件重定向、信号基础
Hello, New World!
01-15 402
一、环境变量（续） "setenv"(3) #include int setenv(const char *name, const char *value, int overwrite); 功能：改变或增加一个环境变量 参数： "name" 要添加或改变的环境变量名 "value" 环境变量的值 "overwrite" 环境变量存在，值取 0 环境变量值不变；值取非 0 环境变量
linux 信号处理 二 (信号的默认处理)
weixin_34026484的博客
11-21 219
今天碰到一个SIGHUP问题，再复习一遍：     有些信号的默认处理方式为“终止+core”，这里的core表示，进程终止时，会在进程的当前工作目录生产一个core文件，该文件是进程终止时的内存快照，以便以后供debugger调试用。     以下情况不会生产core文件：        （1）为程序设置了set-user-ID并且用户不是程序的所有者；        （2）为程序设...
Linux进程间通信——使用信号
haierboos
08-21 738
一、什么是信号 用过Windows的我们都知道，当我们无法正常结束一个程序时，可以用任务管理器强制结束这个进程，但这其实是怎么实现的呢？同样的功能在Linux上是通过生成信号和捕获信号来实现的，运行中的进程捕获到这个信号然后作出一定的操作并最终被终止。 信号是UNIX和Linux系统响应某些条件而产生的一个事件，接收到该信号的进程会相应地采取一些行动。通常信号是由一个错误产生的。但它们还可...
linux 进程间通讯
10-13
Linux 进程间通讯的方式有很多种，包括管道、命名管道、信号、共享内存、消息队列、套接字等。其中，管道和命名管道适用于父子进程之间的通讯，信号适用于进程之间的简单通讯，共享内存和消息队列适用于进程之间大量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值