进程间通信-信号

已于 2024-09-20 10:58:55 修改
阅读量550 收藏
点赞数 13
文章标签： 网络 c语言
于 2024-09-18 19:12:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHB15173352347/article/details/142341174
版权

大部分信号是异步的

/*
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)
    {
    }
}

奋斗的小 Tiger
关注
进程间通信--信号
ShWe的博客
08-16 1809
这篇文章从以下几个方面来了解信号 1、什么是信号 2、信号的产生 3、信号的处理 4、发送信号 5、信号处理函数安全   1、什么是信号？ 信号是一种事件通知机制，当接收到该信号的进程会执行相应的操作 2、信号的产生 由硬件产生，如从键盘输入Ctrl+C可以终止当前进程 由其他进程发送，例如，在shell进程下，使用命令kill  -信号值 PID 异常，当进程异常时发送信...
Linux进程间通信-信号量通信进程互斥实例.pdf
07-11
【Linux进程间通信】在操作系统中，进程间通信（Inter-Process Communication, IPC）是不同进程之间交换数据的重要机制。Linux提供了多种IPC方式，包括管道、消息队列、共享内存、信号量等。本实例主要关注的是...
Linux多进程和多线程(七)进程间通信-信号量
gopher9511的博客
07-06 1625
多个进程竞争同一资源时，会发生资源竞争。资源竞争会导致进程的执行出现不可预测的结果。
进程间通信——信号量
“ 七柒啊 ”的博客
07-29 2338
文章目录前言一、信号量过程总结 前言 信号量是一个特殊的变量，一般取正数值。它的值代表允许访问的资源数目，获取资源时，需要对信号量的值进行原子减一，该操作被称为 P 操作。当信号量值为 0 时，代表没有资源可用，P 操作会阻塞。释放资源时，需要对信号量的值进行原子加一，该操作被称为 V 操作。信号量主要用来同步进程。信号量的值如果只取 0,1，将其称为二值信号量。如果信号量的值大于 1，则称之为计数信号量。 临界资源：同一时刻，只允许被一个进程或线程访问的资源 临界区：访问临界资源的代码段 一、信号量
进程间通信----信号量
m0_60529319的博客
03-27 1230
信号量，是一种特殊的变量：只能对信号量执行P操作和V操作P操作(要执行代码的时候): 如果信号量的值 == 0, 则挂起该进程，如果信号量的值 > 0, 则把该信号量减1V操作(执行完代码的时候): 如果有进程因该信号量而被挂起，则恢复该进程运行，如果没有进程因该信号量而挂起，则把该信号量加1注意：P操作、V操作都是原子操作，即其在执行时，不会被中断。注意：此指的“信号量”是指System V IPC的信号量，与线程所使用的信号量不同。该信号量，用于进程间通信。
Linux进程间通信--信号
码城的博客
08-05 1746
Linux进程间通信--信号机制
进程间通信-信号（一个进程往另一个进程发送信号）
背着行囊去远方的博客
03-10 3530
程序功能： signal.c程序接收两个信号，SIGUSR1，SIGUSR2，接收到SIGUSR1之后，执行sig_usr_close函数，打印，并将全局变量m_switch置为0；接收到SIGUSR2之后，执行sig_usr_open函数，打印，并将m_switch置为1。 kill.c程序主要发送两个信号，SIGUSR1，SIGUSR2。 1、信号发送函数-kill() #inc...
Linux进程间通信-信号量
BIGBurning
11-11 2359
进程间通信的目的： 1.数据传输：一个进程需要
进程间通信------消息队列
weixin_48487878的博客
03-31 3249
文章目录前言一、什么是消息队列？二、消息队列使用的函数1. ftok()函数2、msgget函数总结 前言 消息队列是进程间通信的最主要方法之一，相比于其他方法而言，信号队列成功克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。在多进程之间需要协同处理某个任务时能够合理的进行进程间的同步以及数据交流。 以下是本篇文章正文内容，下面案例可供参考 一、什么是消息队列？ 消息队列（Message Queue,简称MQ）是由内核管理的消息链接表，由消息队列标识符标识，标识符简称队列ID。消
Linux进程间通信 - 信号(signal) 与 管道(pipe) 与 消息队列
cpp_learner的博客
04-30 2572
详细介绍 信号 与 管道 与 消息队列 与 信号量 的用法！
Linux进程间通信-信号通信信号发送实例.pdf
07-11
总结来说，信号通信是Linux IPC的重要组成部分，它提供了简单而快速的进程间通信方式。通过`kill`、`raise`和`sigqueue`等函数，程序员可以灵活地控制和传递信息，实现进程间的交互。然而，由于信号携带信息有限，...
Linux进程间通信-信号通信定时信号实例.pdf
07-11
信号是Linux系统中进程间通信的一种轻量级方式，它能够用来中断进程的执行、改变进程状态或者通知进程发生了某些系统事件。在示例程序中，使用了`<signal.h>`头文件，这是处理信号的必备库。 定时信号通常与`alarm...
Linux进程间通信-信号通信实例.pdf
07-11
信号是Linux系统中用于进程间通信的一种轻量级机制，它允许一个进程向另一个进程发送一个消息，告知接收进程发生了某种事件或需要执行某个动作。信号通信具有快速、简单的特点，但同时也存在信息量有限和同步能力较...
Linux进程间通信-信号量通信进程同步实例.pdf
07-11
在计算机科学领域，特别是在操作系统的设计和实现中，进程间的通信（Inter-Process Communication, IPC）是至关重要的。本文将深入探讨Linux系统中的一个特定IPC机制——信号量（Semaphore）及其在进程同步中的应用...
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
10-15 1160
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
前端开发攻略---8种方法实现在浏览器中跨页面通信
最新发布
nibabaoo的博客
10-15 1254
浏览器实现跨标签页通信的多种方式
Linux系统性能调优技巧详解
运维人生
10-13 612
Linux系统性能调优是一个复杂而持续的过程，需要综合考虑硬件、软件、内核参数、进程管理等多个方面。通过合理的调优措施和持续的监控调整，可以显著提升Linux系统的运行效率和稳定性，为业务提供强有力的支持。性能调优是一个持续的过程，需要不断地监控、分析和调整，以适应不断变化的工作负载和系统环境。希望本文的介绍和代码示例能够帮助您在Linux系统性能调优方面取得更好的效果。
进程间通信：信号量与无名管道详解
本文主要探讨了进程间通信的几种方法，特别是使用信号灯和共享内存的机制。信号灯是实现进程同步的重要工具，而共享内存则提供了高效的数据交换途径。 信号灯集函数`semctl`、`semget`和`semop`是用于管理信号量的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值