进程间通信--信号

最新推荐文章于 2023-02-15 13:36:33 发布
最新推荐文章于 2023-02-15 13:36:33 发布
阅读量134 收藏
点赞数
分类专栏： Linux 文章标签： 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34658196/article/details/113748917
版权

信号

信号共性：简单、不能携带大量信息、满足条件才发送。

信号的特质：信号是软件层面上的“中断”。一旦信号产生，无论程序执行到什么位置，必须立即停止运行，处理信号，处理结束，再继续执行后续指令。所有信号的产生及处理全部都是由【内核】完成的。

产生信号：
1. 按键产生：ctrl+c ctrl+z
2. 调用函数：kill raise abort
3. 定时器：alarm setitimer
4. 命令产生：kill
5. 硬件异常产生：段错误，浮点型错误，总线错误，SIGPIPE
状态：
未决：产生与递达之间状态。
递达：产生并且送达到进程。直接被内核处理掉。
信号处理方式： 执行默认处理动作、忽略、捕捉（自定义）
阻塞信号集（信号屏蔽字）： 用来记录信号的屏蔽状态。一旦被屏蔽的信号，在解除屏蔽前，一直处于未决态。
未决信号集：本质：位图。用来记录信号的处理状态。该信号集中的信号，表示，已经产生，但尚未被处理。

信号4要素：编号、名称、对应事件、默认处理动作（忽略，终止，终止core，暂停，继续）。

kill命令 和 kill函数

int kill（pid_t pid, int signum）
参数：
pid: > 0:发送信号给指定进程
= 0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。
< -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。
= -1：发送信号给，有权限发送的所有进程。
signum：待发送的信号，kill -l查看。
返回值：
成功： 0
失败： -1 errno

//01_kill_parent_process.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>

int main(int argc, char const *argv[])
{
    int i = 0;
    for (; i < 5; ++i)
    {
        pid_t pid = fork();
        if (pid == 0)
            break;
    }

    if (i == 2)
    {
        printf("child process, kill parent process after 5s.\n");
        sleep(5);
        kill(getppid(), SIGKILL);
        while (1)
        {
            sleep(1);
        }
    }
    else if (i == 5)
    {
        while (1)
        {
            printf("parent process.\n");
            sleep(1);
        }
    }
    return 0;
}

//02_kill_child3_process.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>

int main(int argc, char const *argv[])
{
    int i = 0;
    pid_t pid = 0, pid_child_3 = 0;
    for (; i < 5; ++i)
    {
        pid = fork();
        if (pid == 0)
            break;
        else if (pid > 0)
        {
            if (i == 2)
            {
                pid_child_3 = pid;
            }
        }
    }

    if (i == 2)
    {
        while (1)
        {
            printf("child 3, pid = %d.\n", getpid());
            sleep(3);
        }
    }
    if (i == 5)
    {
        printf("parent process, kill child 3 after 5s.\n");
        sleep(5);
        kill(pid_child_3, SIGKILL);
    }
    return 0;
}

//03_raise.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>

int main(int argc, char const *argv[])
{
    printf("kill myself after 2s.\n");
    sleep(2);
    raise(SIGKILL);     //kill(getpid(), SIGKILL)'
    //abort();
    return 0;
}

alarm

alarm 函数：使用自然计时法，定时发送SIGALRM给当前进程。
unsigned int alarm(unsigned int seconds);
参数：
seconds：定时秒数
返回值：上次定时剩余时间。无错误现象。

alarm（0）； 取消闹钟。
time 命令 ： 查看程序执行时间。 实际时间 = 用户时间 + 内核时间 + 等待时间。 --》 优化瓶颈 IO

//04_alarm.c

#include <stdio.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    int ret = alarm(10);
    int i = 0;
    while (1)
    {
        printf("%d second\n", ++i);
        sleep(1);
    }

    return 0;
}

setitimer

setitimer函数：
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);
参数：
which： ITIMER_REAL： 采用自然计时。 ——> SIGALRM
ITIMER_VIRTUAL: 采用用户空间计时 —> SIGVTALRM
ITIMER_PROF: 采用内核+用户空间计时 —> SIGPROF
new_value：定时秒数
old_value：传出参数，上次定时剩余时间。
返回值：
成功： 0
失败： -1 errno

struct itimerval {
    struct timeval {
        time_t      tv_sec;         /* seconds */
        suseconds_t tv_usec;        /* microseconds */
    }it_interval;//---> 周期定时秒数

     struct timeval {
        time_t      tv_sec;         
        suseconds_t tv_usec;        
    }it_value;  //---> 第一次定时秒数  
};

e.g.
            struct itimerval new_t; 
            struct itimerval old_t; 

            new_t.it_interval.tv_sec = 0;
            new_t.it_interval.tv_usec = 0;
            new_t.it_value.tv_sec = 1;
            new_t.it_value.tv_usec = 0;

            int ret = setitimer(&new_t, &old_t);  定时1秒

//05_setitimer.c

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    struct itimerval myit = { { 0, 0 }, { 3, 0 } };     //定义3s以后发送SIGALRM信号
    setitimer(ITIMER_REAL, &myit, NULL);
    while (1)
    {
        printf("Who whill kill me?\n");
        sleep(1);
    }

    return 0;
}

//06_setitimer_cycle.c

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>

void catch_sig(int num)
{
    printf("cat %d sig\n", num);
}

int main(int argc, char const *argv[])
{
    signal(SIGALRM, catch_sig);

    struct itimerval myit = { { 3, 0 }, { 5, 0 } };     //5s后，每隔3s发送1次SIGALRM信号
    setitimer(ITIMER_REAL, &myit, NULL);
    while (1)
    {
        printf("Who whill kill me?\n");
        sleep(1);
    }

    return 0;
}

//07_myalarm.c

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>

unsigned int myalarm(unsigned int seconds)
{
    struct itimerval oldit, myit = { { 0, 0 }, { 0, 0 } };
    myit.it_value.tv_sec = seconds;
    setitimer(ITIMER_REAL, &myit, &oldit);        //seconds后发送SIGALARM信号
    printf("tv_sec = %d, tv_mirsec = %d\n", oldit.it_value.tv_sec, oldit.it_value.tv_usec);
    return oldit.it_value.tv_sec;
}

int main(int argc, char const *argv[])
{
    int ret = -1;
    ret = myalarm(5);
    printf("ret = %d\n", ret);
    //sleep(3);
    ret = myalarm(3);
    printf("ret = %d\n", ret);
    while (1)
    {
        printf("came on baby!\n");
        sleep(1);
    }

    return 0;
}

信号集操作函数：

sigset_t set;  自定义信号集。
sigemptyset(sigset_t *set); 清空信号集
sigfillset(sigset_t *set);  全部置1
sigaddset(sigset_t *set, int signum);   将一个信号添加到集合中
sigdelset(sigset_t *set, int signum);   将一个信号从集合中移除
sigismember(const sigset_t *set，int signum); 判断一个信号是否在集合中。 在--》1， 不在--》0
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); 设置信号屏蔽字和解除屏蔽
参数：
    how:SIG_BLOCK:  设置阻塞
        SIG_UNBLOCK:    取消阻塞
        SIG_SETMASK:    用自定义set替换mask。
    set：    自定义set
    oldset：旧有的 mask。
    
int sigpending(sigset_t *set);  查看未决信号集：
    set： 传出的 未决信号集。

//08_sigpending.c

#include <stdio.h>
#include <unistd.h>
#include <signal.h>

int main(int argc, char const *argv[])
{
    sigset_t pend, sigproc;
    //设置阻塞信号，等待按键产生信号
    sigemptyset(&sigproc);             //先清空
    sigaddset(&sigproc, SIGTSTP);

    //设置阻塞信号集
    sigprocmask(SIG_BLOCK, &sigproc, NULL);

    //循环取未决信号
    while(1)
    {
        sigpending(&pend);
        int i = 1;
        for (; i < 32; ++i)
        {
            if (sigismember(&pend, i) == 1)
            {
                printf("1");
            }
            else
            {
                printf("0");
            }
        }
        printf("\n");
        sleep(1);
    }
    
    return 0;
}

信号捕捉

sighandler_t signal(int signum, sighandler_t handler);
参数：
signum ：待捕捉信号
handler：捕捉信号后的操纵函数

信号捕捉特性：
1. 捕捉函数执行期间，信号屏蔽字 由 mask --> sa_mask , 捕捉函数执行结束。 恢复回mask
2. 捕捉函数执行期间，本信号自动被屏蔽(sa_flgs = 0).
3. 捕捉函数执行期间，被屏蔽信号多次发送，解除屏蔽后只处理一次！

//09_sigaction_mask.c

#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/time.h>

void catch_sig(int num)
{
    printf("begin call, catch %d sig\n", num);
    sleep(5);           //模拟捕捉函数执行时间较长
    printf("end call, catch %d sig\n", num);
}

int main(int argc, char const *argv[])
{
    //注册以下捕捉函数
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = catch_sig;
    sigemptyset(&act.sa_mask);

    //注册捕捉
    sigaction(SIGINT, &act, NULL);

    //setitimer
    while (1)
    {
        printf("who can kill me?\n");
        sleep(1);
    }

    return 0;
}

//10_sigaction_mask.c

#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/time.h>

void catch_sig(int num)
{
    printf("begin call, catch %d sig\n", num);
    sleep(5);           //模拟捕捉函数执行时间较长
    printf("begin call, catch %d sig\n", num);
}

int main(int argc, char const *argv[])
{
    //注册以下捕捉函数
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = catch_sig;
    sigemptyset(&act.sa_mask);

    //注册捕捉
    sigaction(SIGINT, &act, NULL);

    //setitimer
    while (1)
    {
        printf("who can kill me?\n");
        sleep(1);
    }
    
    return 0;
}

//11_child_catch.c

#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>

void catch_sig()
{
    pid_t wpid;
    while ( (wpid = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("wait child %d ok\n", wpid);
    }
}

int main(int argc, char const *argv[])
{
    int i = 0;
    pid_t pid;

    //在创建子进行横之前屏蔽SIGCHLD信号
    sigset_t myset, oldset;
    sigemptyset(&myset);
    sigaddset(&myset, SIGCHLD);
    //oldset保留现场，设置了SIGCHLD到阻塞信号集
    sigprocmask(SIG_BLOCK, &myset, &oldset);

    for (; i < 10; ++i)
    {
        pid = fork();
        if (pid == 0)
            break;
    }

    if (i == 10)
    {
        //parent
        sleep(2);       //模拟注册晚于子进程死亡
        struct sigaction act;
        act.sa_flags = 0;
        sigemptyset(&act.sa_mask);
        act.sa_handler = catch_sig;
        //捕捉
        sigaction(SIGCHLD, &act, NULL);
        //解除屏蔽现场
        sigprocmask(SIG_SETMASK, &oldset, NULL);
        while (1)
        {
            sleep(1);
        }
    }
    else if (i < 10)
    {
        //child
        printf("I am %d child, pid = %d\n", i, getpid());
        //sleep(10 - i);
    }

    return 0;
}

//12_sig_count.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>

pid_t pid;
int count = 0;
int flag = 0;

void cat_sig_father()
{
    sleep(1);
    flag = 1;
    printf("%d\n", count);
    count += 2;
}

void cat_sig_child()
{
    sleep(1);
    flag = 1;
    printf("%d\n", count);
    count += 2;
}

int main(int argc, char const *argv[])
{
    pid = fork();
    if (pid < 0)
    {
        printf("fork error!\n");
        return;
    } 
    else if(pid == 0)
    {
        //child
        count = 1;
        signal(SIGUSR2, cat_sig_child);
        pid_t ppid = getppid();
        while (1)
        {
            if (flag == 1)
            {
                kill(ppid, SIGUSR1);
                flag = 0;
            }
        }
    }
    else 
    {
        sleep(0.01);
        count = 2;
        signal(SIGUSR1, cat_sig_father);
        kill(pid, SIGUSR2);
        while (1)
        {
            if (flag == 1)
            {
                kill(pid, SIGUSR2);
                flag = 0;
            }
        }
    }

    return 0;
}
life is learning
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信--使用信号
09-15
本篇文章主要介绍了Linux进程间通信--使用信号的相关知识。具有很好的参考价值。下面跟着小编一起来看下吧
linux通过信号回调函数,信号机制的管理结构 - Linux内核中的信号机制_Linux编程_Linux公社-Linux系统门户网站...
weixin_42407741的博客
05-03 230
信号只是一个数字，数字为0-31表示不同的信号，如下表所示。编号信号名默认动作说明1SIGHUP进程终止终端断开连接2SIGINT进程终止用户在键盘上按下CTRL+C3SIGQUIT进程意外结束(Dump)用户在键盘上按下CTRL+\4SIGILL进程意外结束(Dump)遇到非法指令5SIGTRAP进程意外结束(Dump)遇到断电，用于调试6SIGABRT/SIGIOT进程意外结束(Dump)7S...
Linux进程信号产生以及捕捉
pythoncjave的博客
02-15 920
生活中，有哪些信号相关的场景呢，比如：红绿灯，闹钟，转向灯等等。1.这里我们要知道，你为什么认识这些信号呢，记住了对应场景下的信号＋后续是有”动作“要你执行的。
Linux进程信号详解
向未来❀去探索 的博客
06-28 696
Linux进程信号详解(信号产生前，信号产生中，信号产生后)
Linux怎么确定信号来源,Linux信号来源和捕获处理以及signal函数简介
weixin_31849265的博客
05-14 832
1、信号是什么？信号本质是什么？日常生活中，绿灯是一个信号，停止标牌是一个信号，裁判手势也是一个信号。信号本质(计算机)：软中断信号(signal，又简称为信号)用来通知进程发生了异步事件。在软件层次上是对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是进程间通信机制中唯一的异步通信机制，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道...
linux篇【10】：进程信号
zhang_si_hang的博客
11-13 3365
(捕捉)①因为一些系统调用例如open()，用户态—>内核态，处理完open的代码后②本来可以返回代码继续执行了，但是正好处于内核态，就顺便去检测信号，并处理信号。③处理信号：若是阻塞或无信号(忽略/默认)就直接内核态—>用户态返回即可 / 若是非阻塞并有信号的自定义捕捉，就内核态—>用户态执行对应的handler方法。（执行handler方法为什么只能是用户态？解释：内核态是什么都可以做的，如果让内核态做用户自定义代码，万一用户写的是一段恶意代码呢???
linux进程发送信号raise,如何在Linux中判断哪个进程向我的进程发送了信号
weixin_29313239的博客
04-29 635
我有一个SIG TERM的Java应用程序。 我想知道发送此信号的进程的pid。那可能吗？两种特定于Linux的方法是SA_SIGINFO和signalfd()，这使程序可以接收有关已发送信号的非常详细的信息，包括发送方的PID。调用sigaction()并将其传递给struct sigaction，该struct sigaction在sa_sigaction中具有所需的信号处理程序，并在sa_f...
1.1进程间通信： 信号 signal()、sigaction()
qq_34738528的博客
08-04 182
一、什么是信号 用过Windows的我们都知道，当我们无法正常结束一个程序时，可以用任务管理器强制结束这个进程，但这其实是怎么实现的呢？同样的功能在Linux上是通过生成信号和捕获信号来实现的，运行中的进程捕获到这个信号然后作出一定的操作并最终被终止。 信号是UNIX和Linux系统响应某些条件而产生的一个事件，接收到该信号的进程会相应地采取一些行动。通常信号是由一个错误产生的。但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二
Linux的信号机制与异步通知机制
u011942916的专栏
03-23 425
1.GPIO异步通知机制 //应用程序需要完成如下三个步骤： （1）signal(SIGIO, sig_handler); 调用signal函数，让指定的信号SIGIO与处理函数sig_handler对应。 （2）fcntl(fd, F_SET_OWNER, getpid()); 指定一个进程作为文件的“属主(filp->owner)”，这样内核才知道信号要发给哪个进程。 （3...
fasync简介
weixiao的博客
11-02 738
　fasync是指应用于系统调用signal和sigaction函数的中断机制。 简单的说，signal函数就是让一个信号与一个函数对应，每当接收到这个信号就会调用相应的函数。 那么什么是异步通知？异步通知类似于中断的机制，当设备可写时，设备驱动函数发送一个信号给内核，告知内核有数据可读,在条件不满足之前，并不会造成阻塞。而不像之前学的阻塞型IO和poll，它们是调用函数进去检查，条件不满足时还会造成阻塞。 使用方式： 其实在应用层启用异步通知只三个步骤： 1）signal(SIGIO,
进程间的通信——信号篇
ZHENYU的博客
07-28 1794
而常用的进程间通信(IPC,Inter-Process Communication)的方法有如下六种: 信号(Signal ) 管道(Pipe) - socket 信号量(Semaphore) 共享内存(Shared Memory) 消息队列(Message Queue) 这里先什么是信号？信号是一种软件中断，提供了一种处理异步事件的方法，也是进程间通信的唯一一个异步的通信方式。Unix中定义了很多信号，有很多条件可以产生信号，对于这些信号有不同的处理方式。进程间信号是如何通信的？.........
Linux进程间通信-信号量通信进程互斥实例.pdf
07-11
Linux进程间通信-信号量通信进程互斥实例.pdf 学习资料 复习资料 教学资源
Linux进程间通信-信号通信实例.pdf
07-11
Linux进程间通信-信号通信实例.pdf 学习资料 复习资料 教学资源
Linux进程间通信-信号通信信号发送实例.pdf
07-11
Linux进程间通信-信号通信信号发送实例.pdf 学习资料 复习资料 教学资源
Linux进程间通信-信号通信定时信号实例.pdf
07-11
Linux进程间通信-信号通信定时信号实例.pdf 学习资料 复习资料 教学资源
node-v12.20.1-sunos-x64.tar.xz
最新发布
04-27
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于Springboot+Vue的乡政府管理系统-毕业源码案例设计.zip
04-27
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。系统化是必要的，设计网上系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于信息的维护和检索也不需要花费很多时间，非常的便利。 网上系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时，也能及时通过数据输入的有效性规则检测出错误数据，让数据的录入达到准确性的目的，进而提升数据的可靠性，让系统数据的错误率降至最低。 关键词：vue；MySQL；SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
一名合格的程序猿修炼手册.md
04-27
一名合格的程序猿修炼手册.
5MHz 函数发生器使用说明书
04-27
5MHz 函数发生器使用说明书
linux系统-进程间通信
07-27
\[1\]\[2\]常见的进程间通信方式包括共享内存、管道、消息队列和信号量等。\[2\]在实现进程间通信时，需要关闭对应的文件描述符，子进程关闭读端，父进程关闭写端，然后通过读写操作进行数据的传输。\[3\]通过这种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值