首页 > 系统相关 >进程间通信-信号

进程间通信-信号

时间：2024-09-20 10:53:29浏览次数：3  
标签：set int signal 阻塞 间通信 sig 信号 进程

大部分信号是异步的

/*
1-31号信号		非实时信号（所有非实时信号优先级相同）		---不可靠信号
不可靠：处于就绪队列多个相同的非实时信号只会被响应一次，其余的被丢弃
特征：
1、不排队，会相互嵌套（例如家里来客人1先来，招待1的过程中2来了就立马去招待2）
2、处于就绪队列多个相同的非实时信号只会被响应一次，其余的被丢弃
3、非实时信号都有对应的系统时间，一旦发生就响应

34-64号信号	实时信号（数字代表优先级，实时高于非实时）	---可靠信号
可靠：处于就绪队列多个相同的实时信号全部会被响应
特征：
1、排队，不嵌套
2、处于就绪队列多个相同的实时信号全部会被响应
3、实时信号没有与之对应的系统事件
*/
以下属于了解部分
/*
进程可以响应对应的信号的过程（这就是一个记录过程，防止延时、多个信号量同时响应，起到暂存的作用）：
struct task_struct; ---> struct signal_struct *signal; (掌管进程信号结构体)---> struct sigpending shared_pending; (共享挂起队列)---> struct list_head list; (内核链表)---> sigset_t signal[64];(信号集)//unsigned long sig[64]
当收到对应信号时，将数组其对应位置置为1，随后将数组遍历即可响应对应信号；(若为阻塞，只是遍历时略过相应的1，等到不阻塞执行)
    也需要注意，信号发出被响应的对象是进程组、会话期，也就是影响多个进程，所以需要内核链表；
*/
    //共享挂起队列作用：通过内核链表将相关进程信号集串联
以上就类似于电脑快捷键，快捷键本身没有相关功能，只是快捷键调用了相关函数，实现对应功能。

/*
struct task_struct; ---> struct signal_struct *signalhand; ---> struct k_sigaction action[_NSIG];	(用于捕捉：  1、执行缺省动作	2、忽略	3、响应（用于连接用户自己写的函数）)
*/
函数-kill
#include <sys/types.h>
#include <signal.h>
/*
功能：指定进程发送信号
参数1：大于0 发送到指定PID进程
参数2：要发送信号
返回值：成功返回0 失败返回-1
*/
int kill(pid_t pid, int sig);
案例
int main(int argc, char* argv[])
{
    int pid = atoi(argv[1]);
    
    kill(pid, SIGINT);
    
    return 0;
}
//./a.out PID

kill -l	//Linux系统查看所有信号命令

kill -s SIGINT 2557
kill -2 2557	//2是对应的信号编号//给pid2557进程发送信号
    
kill -2 a.out
kill -s SIGINT a.out	//给名称为a.out的进程发送信号
函数-signal
#include <signal.h>
/*
功能：捕捉指定信号，为信号到来做相应准备
参数1：要捕捉信号
参数2：SIGDFL 缺省	SIG_IGN 忽略	void(*p)(int) 指定响应函数
返回值：成功返回第二个参数返回值 失败返回SIG_ERR
*/
void (*signal(int sig, void(*func)(int)))(int);
案例
int main(int argc, char* argv)
{
    //缺省：无需任何操作
    
    //忽略：信号过来直接丢弃	SIGKILL\SIGSTOP无法忽略
    //signal(SIGINT,SIG_IGN);
    
    //响应
    //signal只是用于注册，并未产生阻塞；当SIGINT信号出现，系统调用fun函数（并不是我们自己调用）  产生一次，响应一次
    signal(SIGINT, fun);
    
    while(1)
    {
        printf("Hello World\n");
        sleep(3);
    }
    return 0;
}
void fun(int sig)
{
    printf("相应我的是%d\n", sig);
}
函数-raise
#include <signal.h>
/*
功能：自己给自己发送指定信号
参数：要发送的信号
返回值：成功返回0 失败返回非0
*/
int raise(int sig);
函数-pause
#include <unistd.h>
/*
功能：挂起进程，直到收到一个信号
参数：void
返回值：收到非致命信号或已经捕捉信号返回-1 否则不返回
*/
int pause(void);
函数-sigemptyset-sigfillset-sigaddset-sigdelset-sigismember-sigprocmask
#include <signal.h>
/*
sigemptyset();	清空信号集
sigfillset();	将所有信号添加到信号集
sigaddset();	将指定信号添加到信号集
sigdelset();	将指定信号从信号集剔除
sigismember();	判断执行信号是否被信号集包含
参数1：信号集
参数2：要添加、剔除、判断的信号
返回值：
	成功：sigismember返回1 其余返回0
	失败：sigismember返回0 其余返回-1
*/
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);
    
    
#include <signal.h>
/*
功能：阻塞或解除一个或多个信号
参数1：
	SIG_BLOCK 	原有阻塞信号基础上，添加set信号
	SIG_SETMASK	原有阻塞信号替换为set中信号
	SIG_UNBLOCK	原有阻塞信号基础上，解除set信号
参数2：信号集
参数3：原有信号集
返回值：成功返回0 失败返回-1
*/
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
//特别注意：阻塞不是函数阻塞，而是信号具有阻塞特性；好比read函数读取大文件需要时间，而这个阻塞并不是read具有的，而是文件设有阻塞特性，必须读完才能下一步
案例
int main()
{
    //1、注册信号和函数
    signal(SIGINT,fun);
    signal(SIGQUIT,fun);
    
    //2、信号集操作
    sigset_t set;
    sigemptyset(&set);	//清空信号集-->想当初初始化set变量
    sigaddset(&set,SIGINT);
    sigaddset(&set,SIGQUIT);	//添加信号到信号集中
    
    //3、阻塞信号集中的所有信号
    sigprocmask(SIG_BLOCK, &set, NULL);
    
    //4、当前循环只能用于延时，只是为了延长阻塞时间
    //若延时过程中，被设置为阻塞信号过来会直接阻塞而不会响应
    //若在延时阻塞过程中，非实时信号多次发送，同一信号只会响应一次，其余丢弃
    //若在延时阻塞过程中，非实时信号多次发送，不同信号都会响应，顺序随机
    
    int i = 10;
    while(1)
    {
        printf("%d\n", i--);
        sleep(1);
    }
    
    //5、手动解除阻塞，若不然将一直阻塞
    sigpromask(SIG_UNBLOCK, &set, NULL);
}
函数-sigqueue
#include <signal.h>
/*
功能：向某一进程发送指定信号，同时携带数据
参数1：目标进程PID
参数2：要发送的信号
参数3：携带的额外数据
返回值：成功返回0 失败返回-1
*/
int sigqueue(pid_t pid, int sig, const union sigval value);
函数-sigaction
#include <signal.h>
/*
功能：捕捉指定信号
参数1：要捕捉的信号
参数2：
参数3：原有的信号处理参数
返回值：成功返回0 失败返回-1
*/
int sigaction(int signum, const struct sigaction* act, struct sigaction* oldact);

结论：

  1. 当一个进程设置了阻塞掩码，其子进程回继承阻塞掩码；

  2. 挂起信号不会被子进程继承；

  3. 非实时信号可以相互嵌套，实时信号也可以相互嵌套；

void fun(int sig)
{
    printf("sig = %d\n", sig);
}

int main(int argc,char *argv[])
{
    // 1、注册信号和函数
    signal(SIGINT, fun);
    signal(SIGQUIT, fun);

    // 2、信号集操作
    sigset_t set;
    sigemptyset(&set); // 清空信号集-->相当于是初始化set变量
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT); // 添加信号到信号集中

    // 3、阻塞信号集中的所有信号
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 4、当前循环只是用于延时，目的只是为了让阻塞时间长一点。
    // 如果在延时过程中被设置为阻塞的信号过来后，信号会被直接阻塞，而不会立即响应。
    // 如果延时(阻塞)过程中，非实时信号被多次发送，那么同一个非实时信号在解除阻塞后只能被响应一次，其余则会被丢弃。
    // 不同的多个非实时信号都会被响应，至于响应的顺序是随机的。
    int i = 10;
    while(i)
    {
        printf("%d\n", i--);
        sleep(1);
    }

    // 5、解除阻塞(切记被设置为阻塞的信号，最终一定要手动在解除阻塞)
    sigprocmask(SIG_UNBLOCK, &set, NULL);

    return 0;
}

4.非实时信号（切记：一定是处于就绪队列）若重复发送一个信号，只会被接收一次；

注意：延时过程中捕获的信号会被立即响应（模拟人浅度睡眠按门铃）

void fun(int sig)
{
    printf("receive a SIGUSR1!\n");
}

int main(int argc,char *argv[])
{
    printf("my pid: %d\n", getpid());

    // 注册信号
    signal(SIGUSR1, fun);

    // 阻塞信号
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 当前的延时，只是为了让我们有时间多次发送信号。
    // 延时相当于挂起。
    // 如果没有阻塞的情况下，延时过程中捕获的信号会被立即响应。
    int num = 10;
    while(num)
    {
        // 输出语句只是当纯为了看到时间流失的过程
        printf("%d\n", num--);
        sleep(1);
    }

    sigprocmask(SIG_UNBLOCK, &set, NULL);

    return 0;
}

5.实时信号若重复发送一个信号，会全部接收；

void fun(int sig)
{
    printf("receive a SIGRTMIN!\n");
}

int main(int argc,char *argv[])
{
    printf("my pid: %d\n", getpid());

    // 注册信号
    signal(SIGRTMIN, fun);

    // 阻塞信号
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGRTMIN);
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 当前的延时，只是为了让我们有时间多次发送信号。
    // 延时相当于挂起。
    // 如果没有阻塞的情况下，延时过程中捕获的信号会被立即响应。
    int num = 10;
    while(num)
    {
        // 输出语句只是当纯为了看到时间流失的过程
        printf("%d\n", num--);
        sleep(1);
    }

    sigprocmask(SIG_UNBLOCK, &set, NULL);

    return 0;
}

6.实时信号、非实时信号响应优先级；

//send_sig.c
int main(int argc,char *argv[])
{
    printf("目标进程的PID：%d\n", atoi(argv[1]));

    int i = 0;
    for (i = SIGHUP; i <= SIGRTMAX; i++)
    {
        if (i == SIGKILL || i == SIGSTOP || i == 32 || i == 33)
        {
            continue;
        }

        // 将所有的信号发送给目标进程
        kill(atoi(argv[1]), i);
    }

    return 0;
}
//recv_sig.c
void fun(int sig)
{
    printf("%d\n", sig);
}

int main(int argc,char *argv[])
{
    printf("my pid = %d\n", getpid());

    // 1、创建信号集并初始化
    sigset_t set;
    sigemptyset(&set);
    
    int i = 0;
    for (i = SIGHUP; i <= SIGRTMAX; i++)
    {
        if (i == SIGKILL || i == SIGSTOP || i == 32 || i == 33)
        {
            continue;
        }

        // 2、注册信号
        signal(i, fun);

        // 3、将注册的信号加入到信号集中
        sigaddset(&set, i);
    }

    // 4、将信号集中的60个信号全部设置为阻塞状态
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 只是为了等待发送信号的程序被执行
    printf("阻塞之后，开始挂起10秒钟!\n");
    sleep(10);

    // 5、解除阻塞掩码
    sigprocmask(SIG_UNBLOCK, &set, NULL);

    return 0;
}

7.解决信号嵌套问题；

void f(int sig)
{
    printf("sig = %d\n", sig);

    int count = 10;
    if (sig == SIGUSR1)
    {
        while(count--)
        {
            printf("1\n");
            sleep(1);
        }
    }
    else if (sig == SIGUSR2)
    {
        while(count--)
        {
            printf("2\n");
            sleep(1);
        }
    }   
}

int main(int argc,char *argv[])
{
    printf("my pid: %d\n", getpid());

    // 1、注册两个信号，用于测试这两个信号是否会进行嵌套
    signal(SIGUSR1, f);
    signal(SIGUSR2, f);

    /* 对当前参数act进行设置 */
    struct sigaction act;
    
    // 指向标准的信号响应函数，因为当前并没有设置sa_flags
    act.sa_handler = f; 

    // 将两个信号添加到临时阻塞掩码中
    bzero(&act.sa_mask, sizeof(act.sa_mask));
    sigaddset(&act.sa_mask, SIGUSR1);
    sigaddset(&act.sa_mask, SIGUSR2);

    // 当响应SIGUSR2时，先阻塞SIGUSR1，等待SIGUSR2执行完毕后，在响应SIGUSR1
    // st@st-virtual-machine:~$ kill -s SIGUSR2 2997
    // st@st-virtual-machine:~$ kill -s SIGUSR1 2997
    sigaction(SIGUSR2, &act, NULL);

    // 当响应SIGUSR1时，先阻塞SIGUSR2，等待SIGUSR1执行完毕后，在响应SIGUSR2
    // st@st-virtual-machine:~$ kill -s SIGUSR1 2991
    // st@st-virtual-machine:~$ kill -s SIGUSR2 2991
    sigaction(SIGUSR1, &act, NULL);

    // 只是为了让当前进程不退出
    while(1)
    {
    }
}

标签：set,int,signal,阻塞,间通信,sig,信号,进程
From： https://blog.csdn.net/LHB15173352347/article/details/142341174

相关文章

  • 11 UML中的逻辑视图、进程视图、实现视图、部署视图
    UML（UnifiedModelingLanguage，统一建模语言）是一种用于对软件密集系统进行可视化建模的标准语言。在UML中，系统可以从不同的角度进行描述，这些不同的角度被称为视图。具体来说，UML中的逻辑视图、进程视图、实现视图和部署视图分别代表了系统的不同方面。1.逻辑视图（LogicalView）定义......
  • KU060信号处理板卡设计原理图： 385-基于6U CPCIe的TMS320C6678+KU060的信号处理板卡
    基于6UCPCIe的TMS320C6678+KU060的信号处理板卡一、板卡概述   基于6UCPCIe的C6678+KU060的信号处理板卡是新一代FPGA的高性能处理板卡。板卡采用一片TIDSPTMS320C6678和一片Xilinx公司XCKU060-2FFVA1156I作为主处理器，Xilinx的AritexXC7A200T作为辅助处理器。XC7A20......
  • Linux | 进程间通信：管道、消息队列、共享内存与信号量
    文章目录《深入理解进程间通信：管道、消息队列、共享内存与信号量》一、进程间通信介绍（一）进程间通信目的（二）进程间通信发展（三）进程间通信分类二、管道（一）什么是管道（二）匿名管道（三）管道特点（四）命名管道三、共享内存（一）共享内存简介（二）共享内存数据结构（三）共享内存函数四、消息队......
  • 【原创】解决NasCab掉进程，NasCab进程维护
    最近对象吐槽家里服务器又连不上，看不了考研视频了。我掏出手机一试，确实连不上。家里的服务器是Win11平台，用NasCab管理的视频文件，然后通过frpc做的内网穿透。我们在外面的图书馆，连不上无非是三种情况：服务器关机了、NasCab内网穿透插件掉了、NasCab进程掉了。远程登录服务器，发现......
  • 数字调制解调技术的MATLAB与FPGA实现-FPGA实现数字信号处理基础 【2.6】
    4.2.3IR与FIR滤波器的比较        IIR滤波器与FIR滤波器是最常见的数字滤波器，两者的结构及分析方法相似。为更好地理解两种滤波器的异同，下面对其进行简单的比较，以便在具体工程设计中更合理地选择滤波器种类，以更少的资源获取所需的性能。本节先直接给出两种滤波......
  • 数字调制解调技术的MATLAB与FPGA实现-FPGA实现数字信号处理基础 【2.8】
    4.5滤波器设计分析工具        FDATOOL(FilterDesign&AnalysisTool)是MATLAB信号处理工具箱里专用的滤波器设计分析工具，MATLAB6.0以上的版本还专门增加了滤波器设计工具箱(FilterDesignToolbox)。FDATOOL可以设计包括FIR和IR的几乎所有基本的常规滤波器,它操作......
  • Linux 基础入门操作 第九章 进程之间通讯信号量
    systemV的进程间通信之信号量9.3信号量信号量与其他进程间通信方式不大相同，它主要提供对进程间共享资源访问控制机制。相当于内存中的标志，进程可以根据它判定是否能够访问某些共享资源，同时，进程也可以修改该标志。除了用于访问控制外，还可用于进程同步。信号量有以下两......
  • 进程和线程基础内容
    什么是进程和线程？进程是指运行中的程序，在windows里可以在任务管理器中查看；线程是CPU调度的基本单位，进程可以看成程序执行的一个实例。一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。进程就是线程的容器，需要线程利用进程中的一些资源，处理一个代码、指令。最终实现进......
  • 操作系统：线程间通信方式（上）：锁机制详解
    操作系统：线程间通信方式（上）：锁机制详解在多线程编程中，多个线程共享资源是常见的需求，但资源竞争会导致数据不一致和冲突问题。锁机制是一种用于控制线程对共享资源访问的同步方式，确保同一时刻只有一个线程能够访问临界区（CriticalSection）。本文将详细介绍线程间通信中的锁机......
  • 操作系统之进程
    概念进程是程序的一次执行过程，是动态的。程序则是存放在磁盘上的可执行文件，属于静态。进程是程序的实体运行过程，是系统进行资源分配和调度的独立单位。组成进程控制块（PCB）：PID：进程标识符，用于唯一标识一个进程。UID：用户标识符，标识创建该进程的用户。进程控制和管理信息：用于......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99