进程间通信系列 之 信号综合实例

最新推荐文章于 2024-06-25 22:04:46 发布
原创 最新推荐文章于 2024-06-25 22:04:46 发布 · 2.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#进程间通信 #信号

本文深入探讨了进程间通信(IPC)的各种机制，包括信号、共享内存、命名管道(FIFO)等，并提供了丰富的实例代码，帮助读者理解不同IPC方法的特点与应用场景。

 进程间通信系列 之 概述与对比   http://blog.csdn.net/younger_china/article/details/15808685
 进程间通信系列 之 共享内存及其实例   http://blog.csdn.net/younger_china/article/details/15961557
 进程间通信系列 之 共享内存简单实例   http://blog.csdn.net/younger_china/article/details/15991081
 进程间通信系列 之 信号(理论)   http://blog.csdn.net/younger_china/article/details/15976961
 进程间通信系列 之 信号实例   http://blog.csdn.net/younger_china/article/details/15968715
 进程间通信系列 之 信号综合实例   http://blog.csdn.net/younger_china/article/details/15980485
 进程间通信系列 之 命名管道FIFO及其应用实例   http://blog.csdn.net/younger_china/article/details/15808531
 进程间通信系列 之 管道(客户端和服务端通信)   http://blog.csdn.net/younger_china/article/details/15809281
 进程间通信系列 之 信号量详解及编程实例   http://blog.csdn.net/younger_china/article/details/15808531
 进程间通信系列 之 消息队列函数及其范例   http://blog.csdn.net/younger_china/article/details/15503871
 进程间通信系列 之 消息队列应用实例   http://blog.csdn.net/younger_china/article/details/15808501 
 进程间通信系列 之 socket套接字及其实例   http://blog.csdn.net/younger_china/article/details/15809163
 进程间通信系列 之 socket套接字实例   http://blog.csdn.net/younger_china/article/details/15809207


原文地址：进程间通信--信号(进程间通信唯一的异步方式) 作者：Deem_passion

一、信号的介绍


信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。

信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了那些系统事件。

如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递个它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞取消时才被传递给进程。

二、linux操作系统支持的信号

A. kill  -l


B.常用信号的含义

三、信号的产生

A.用户在终端按下某些键时，终端驱动程序会发送信号给前台进程，例如ctr+c产生SIGINT,  ctr + \产生SIGQUI信号，ctr + z产生SIGTSTP。
B.硬件异常产生信号，这些条件由硬件检测到并通知内核，然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令，CPU的运算单元会产生异常，内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址，MMU会产生异常，内核将这个异常解释为SIGSEGV信号发送给当前进程 。
C.一个进程调用int kill(pid_t pid,int sig)函数可以给另一个进程发送信号
D.可以用kill命令给某个进程发送信号，如果不明确指定信号则发送SIGTERM信号，该信号的默认处理动作是终止进程。
E.当内核检测到某种软件条件发生时也可以通过信号通知进程，例如闹钟超时产生SIGALRM信号，向读端已关闭的管道写数据时产生SIGPIPE信号。

四、进程对信号的处理

A.忽略此信号
B.执行该信号的默认处理动作
C.提供一个信号处理函数，要求内核在处理该信号时切换到用户态执行这个处理函数，这种方式成为捕捉(Catch)一个信号。
 
五、相关信号API

A.通过系统调用向一个指定的进程发送信号


参数说明:
第一个参数：指定发送信号的接收线程
第二个参数：信号的signum

案例一、
父进程从终端输入signum,然后发给子进程 
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>

int main()
{
    int pid;

    if((pid = fork()) < 0)
    {
    
        perror("Fail to fork");
        exit(EXIT_FAILURE);
    
    }else if(pid == 0){
        
        while(1);
    
    }else{
        
        int signum;
        
        while(scanf("%d",&signum) == 1)
        {
            kill(pid,signum);
            system("ps -aux | grep a.out");
        }
    }

    return 0;
}


运行结果如下:

B.捕捉一个信号

对应的API

其原型:

 

我们一般都是用第一个，也就是通过typedef改写过的。

注意：signal函数我一般认为其是向内核注册当前进程收到信号的处理的方式。
signal(SIGINT,handler);


参数说明:

signum  :  指定信号
handler  :  SIG_IGN忽略该信号，SIG_DFL采用系统默认方式处理信号,自定义的信号处理函数指针。

案例探究:

通过异步方式，给子进程收尸

注意：子进程在终止时会给父进程发SIGCHLD，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需要专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。 
<span style="font-size:12px;">#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>

void child_exit_handler(int signum)
{
    if(signum == SIGCHLD)
    {
        printf("Child exit.\n");
        wait(NULL);
    }
}

int main()
{
    int pid;
    int i = 0;

    //想内核注册，处理 SIGCHLD信号的方式
    signal(SIGCHLD,child_exit_handler);

    if((pid = fork()) < 0)
    {
        perror("Fail to fork");
        exit(EXIT_FAILURE);

    }else if(pid == 0){
        
        for(i = 0;i < 5;i ++)
        {
            printf("child loop.\n");
            sleep(1);
        }
    
    }else{
        
        for(i = 0;i < 5;i ++)
        {
            printf("Father loop.\n");
            sleep(2);
        }

    }

    exit(EXIT_SUCCESS);
}</span>
 
C.闹钟函数alarm


larm()也称为闹钟函数，它可以在进程中设置一个定时器。当定时器指定的时间到时，内核就向进程发送SIGALARM信号。

seconds:指定的秒数，如果参数seconds为0，则之前设置的闹钟会被取消，并将剩下的时间返回。

成功:如果调用此alarm()前，进程中已经设置了闹钟时间，则放回上一个闹钟时间的剩余时间，否则返回0。

alarm(100);
........

......

alarm(5);

出错:-1

案例探究: 
<span style="font-size:12px;">#include <stdio.h>
#include <signal.h>
#include <stdlib.h>

void handler(int signum)
{
    if(signum == SIGALRM)
    {
        printf("Recv SIGALARM.\n");
    }

    exit(EXIT_SUCCESS);
}

int main()
{
    int count = 0;
    int n = 0;

    signal(SIGALRM,handler);

    n = alarm(10);

    printf("n = %d.\n",n);
    
    sleep(2);

    n = alarm(5);

    printf("n = %d.\n",n);
    
    while(1)
    {
        printf("count = %d.\n", ++count);
        sleep(1);
    }

    return 0;
}</span>
运行结果如下：




案例二、综合案例

使用FIFO实现clientA与clientB之间聊天
A.输入quit后，两个进程退出
B.如果在20秒内，没有等到另一端发来的消息，则认为对方已不在，此时终止。

clientA: 
<span style="font-size:12px;">#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

#define MAX 100

void signal_handler(int signum)
{
    static int flag = 0;

    switch(signum)
    {
        case SIGALRM:
            if(flag == 0)
            {
                printf("The people is leaving,the system is closed in 10 seconds \
                        and you can input 'ctrl + c' cancel.\n");
                alarm(10);
            }else{
                
                kill(getppid(),SIGKILL);
                usleep(500);
                exit(EXIT_SUCCESS);
            }

            flag = 1;            
            break;

        case SIGINT:
            printf("The alarm is cancel.\n");
            alarm(0);
            break;
    }

}

int child_recv_fifo(char *fifo_name)
{
    int n,fd;
    char buf[MAX];

    if((fd = open(fifo_name,O_RDONLY)) < 0)
    {
        fprintf(stderr,"fail to open %s : %s.\n",fifo_name,strerror(errno));
        return -1;
    }

    signal(SIGALRM,signal_handler);
    signal(SIGINT,signal_handler);
    alarm(15);//璁剧疆瀹氭椂鍣?    
    while(1)
    {
        n = read(fd,buf,sizeof(buf));
        buf[n] = '\0';

        printf("Read %d bytes : %s.\n",n,buf);

        if(strncmp(buf,"quit",4) == 0 || n == 0)
        {
            kill(getppid(),SIGKILL);
            usleep(500);
            exit(EXIT_SUCCESS);
        }

        alarm(15);
    }

    return 0;
}

int father_send_fifo(char *fifo_name,int pid)
{
    int n,fd;
    char buf[MAX];

    if((fd = open(fifo_name,O_WRONLY)) < 0)
    {
        fprintf(stderr,"Fail to open %s : %s.\n",fifo_name,strerror(errno));
        return -1;
    }

    signal(SIGINT,SIG_IGN);

    while(1)
    {
        getchar();
        printf(">");

        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1] = '\0';

        write(fd,buf,strlen(buf));

        if(strncmp(buf,"quit",4) == 0)
        {
            kill(pid,SIGKILL);
            usleep(500);
            exit(EXIT_SUCCESS);
        }
    }

    return 0;
}

int main(int argc,char *argv[])
{
    int pid;

    if(argc < 3)
    {
        fprintf(stderr,"usage %s argv[1].\n",argv[0]);
        exit(EXIT_FAILURE);
    }

    if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
    {
        perror("Fail to mkfifo");
        exit(EXIT_FAILURE);
    }

    if(mkfifo(argv[2],0666) < 0 && errno != EEXIST)
    {
        perror("Fail to mkfifo");
        exit(EXIT_FAILURE);
    }
    
    if((pid = fork()) < 0)
    {
    
        perror("Fail to fork");
        exit(EXIT_FAILURE);
    
    }else if(pid == 0){
        
        child_recv_fifo(argv[2]);
    
    }else{

        father_send_fifo(argv[1],pid);
    }

    exit(EXIT_SUCCESS);
}</span>

client B

<span style="font-size:12px;">#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

#define MAX 100

void signal_handler(int signum)
{
    static int flag = 0;

    switch(signum)
    {
        case SIGALRM:
            if(flag == 0)
            {
                printf("The people is leaving,the system is closed in 10 seconds \
                        and you can input 'ctrl + c' cancel.\n");
                alarm(10);
            }else{
                
                kill(getppid(),SIGKILL);
                usleep(500);
                exit(EXIT_SUCCESS);
            }

            flag = 1;            
            break;

        case SIGINT:
            printf("The alarm is cancel.\n");
            alarm(0);
            break;
    }

}

int child_recv_fifo(char *fifo_name)
{
    int n,fd;
    char buf[MAX];

    if((fd = open(fifo_name,O_RDONLY)) < 0)
    {
        fprintf(stderr,"fail to open %s : %s.\n",fifo_name,strerror(errno));
        return -1;
    }

    signal(SIGALRM,signal_handler);
    signal(SIGINT,signal_handler);
    alarm(15);//璁剧疆瀹氭椂鍣?    
    while(1)
    {
        n = read(fd,buf,sizeof(buf));
        buf[n] = '\0';

        printf("Read %d bytes : %s.\n",n,buf);

        if(strncmp(buf,"quit",4) == 0 || n == 0)
        {
            kill(getppid(),SIGKILL);
            usleep(500);
            exit(EXIT_SUCCESS);
        }

        alarm(15);
    }

    return 0;
}

int father_send_fifo(char *fifo_name,int pid)
{
    int n,fd;
    char buf[MAX];

    if((fd = open(fifo_name,O_WRONLY)) < 0)
    {
        fprintf(stderr,"Fail to open %s : %s.\n",fifo_name,strerror(errno));
        return -1;
    }

    signal(SIGINT,SIG_IGN);

    while(1)
    {
        getchar();
        printf(">");

        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1] = '\0';

        write(fd,buf,strlen(buf));

        if(strncmp(buf,"quit",4) == 0)
        {
            kill(pid,SIGKILL);
            usleep(500);
            exit(EXIT_SUCCESS);
        }
    }

    return 0;
}

int main(int argc,char *argv[])
{
    int pid;

    if(argc < 3)
    {
        fprintf(stderr,"usage %s argv[1].\n",argv[0]);
        exit(EXIT_FAILURE);
    }

    if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
    {
        perror("Fail to mkfifo");
        exit(EXIT_FAILURE);
    }

    if(mkfifo(argv[2],0666) < 0 && errno != EEXIST)
    {
        perror("Fail to mkfifo");
        exit(EXIT_FAILURE);
    }
    
    if((pid = fork()) < 0)
    {
    
        perror("Fail to fork");
        exit(EXIT_FAILURE);
    
    }else if(pid == 0){
        
        child_recv_fifo(argv[1]);
    
    }else{

        father_send_fifo(argv[2],pid);
    }

    exit(EXIT_SUCCESS);
}
</span>


 

 


进程间通信——信号
蹦跶跶
08-04 1108
进程间通信——信号1. 信号的概念1.1 信号的机制1.1 与信号相关的事件和状态1.3 信号的编号1.4 信号四要素1.5 Linux常规信号一览表2. 信号的产生方式2.1 终端按键产生信号2.2 硬件异常产生信号2.3 kill函数/命令产生信号2.4 raise和abort函数2.5 软件条件产生信号2.5.1 alarm函数2.5.2 setitimer函数3. 信号集操作函数3.1 信号集设定3.2 sigprocmask函数3.3 sigpending函数4. 信号捕捉4.1 signal函数
进程间通信：信号
weixin_43887148的博客
11-10 1304
信号 信号是UNIX和Linux系统响应某些条件而产生的一个事件。接收到该信号的进程会相应地采取一些行动。我们用术语生成(raise)表示一个信号的产生，使用术语捕获(catch)表示接收到一个信号。 信号是由于某些错误条件而生成的，如内存段冲突、浮点处理器错误或非法指令等。它们由shell和终端处理器生成来引起中断，它们还可以作为在进程间传递消息或修改行为的一种方式，明确地由一个进程发送给另一个进程。无论何种情况，它们的编程接口都是相同的。信号可以被生成、捕获、响应或(至少对于一些信号）忽略。 信号的名称
进程间通信（一）：信号
csy777777的博客
05-17 284
前言 信号是软件中断的一种，是一种较早产生的进程间通信机制，信号的名称都以“SIG”开头，比如常见的SIGABRT、SIGALRM等。 信号的种类 Linux中的信号被定义为正整数常量，在bits/signum.h文件中如下： #define SIGSTKFLT 16 /* Stack fault (obsolete). */ #define SIGPWR 30 /* Power failure imminent. */ /* Historical signals specified by POSI
进程间通信系列 之 信号实例
weixin_30622107的博客
11-13 167
进程间通信系列 之 概述与对比http://blog.csdn.net/younger_china/article/details/15808685 进程间通信系列 之 共享内存及其实例 http://blog.csdn.net/younger_china/article/details/15961557 进程间通信系列 之 共享内存简单实例 http://blog....
linux进程通信信号实例,Linux进程间通信 --- 信号量(示例代码)
weixin_29799175的博客
04-28 363
信号量 IPC 原理信号量通信机制主要用来实现进程间同步，避免并发访问共享资源。信号量可以标识系统可用资源的个数。最简单的信号量为二元信号量下图为 Linux 信号量通信机制的概念图。在实际应用中，两个进程通信可能会使用多个信号量，因此，Linux 在管理时以信号量集合的概念来管理。通常所说的创建一个信号量实际上是创建了一个信号量集合，在这个信号量集合中，可能有多个信号量。整个信号量集合由以下部分...
c语言 system v风格 使用共享内存及信号量进程间通信示例
抟土成人祖，炼石补青天。眼中览银河，手可摘星辰。
02-25 748
信号处理代码注册了一个信号处理函数，用来捕获SIGALRM信号并打印该信号的描述。这样可以防止进程因收到此信号而终止。共享内存创建与挂载使用shmget创建或获取一个共享内存段，大小为 1024 字节，权限为 0777。共享内存是用于在多个进程之间共享数据的。使用shmat挂载共享内存段到当前进程的地址空间，使得进程能够访问这块共享内存。ipc_stat函数用于打印共享内存的状态信息，包括创建进程的 PID、内存大小和当前的连接数。信号量的创建与操作使用semget。
进程间通信实例演示与详解
套接字（Sockets）是网络通信中最常见的进程间通信机制之一，允许不同主机上的进程通过网络进行数据交换。 4. Linux/Unix下的进程通信：在类Unix系统中，进程通信经常使用管道、消息队列、共享内存等方法。例如，...
【嵌入式Linux】＜总览＞ 进程间通信
致力于Linux的博客
06-25 2075
在文章【嵌入式Linux】＜总览＞ 多进程中已经介绍了进程的相关概念和创建多个进程的方法。本篇聚焦于进程间通信的方式，若涉及版权问题请联系本人删除。
行业分类-设备装置-一种进程间通信方法及装置.zip
09-04
1. **IPC基础知识**：介绍进程的概念，解释为什么需要进程间通信以及它的基本类型，如管道、消息队列、信号量、共享内存、套接字等。 2. **方法概述**：详细描述所提出的进程间通信方法，包括其创新点和与传统IPC...
操作系统Linux命令与进程线程同步通信技术实战：系统管理与并发编程综合应用方案设计
最新发布
08-29
内容概要：本文系统介绍了操作系统相关的实用技巧与实战项目，涵盖Linux常用命令、线程同步机制和进程间通信（IPC）三大核心内容。Linux命令部分按功能分类讲解了文件操作、系统信息查看、网络配置、文本处理、权限...
进程间通讯-信号
123木头人的博客
02-04 811
信号是一种软件中断，用于告知一个进程发生了某个事件。信号可以由操作系统、由其他进程，或者由进程本身发出。是一种异步通信方式,一般具有如下特点:（1）进程在运行过程中，随时可能被各种信号打断（2）进程可以忽略,或者去调用相应的函数去处理信号（3）进程无法预测到达的精准时间再补充说明下是异步通信方式。异步通信是一种计算机通信方式，其中数据的发送和接收不需要同时发生。在异步通信模式中，发送方和接收方不需要同步工作；发送方可以在任何时候发送数据，而接收方则在数据到达时处理数据。
进程间通信（信号）
zy627836411的博客
04-01 377
linux系统进程间通信有很多种方式：较多使用的有信号，管道以及System VIPC。各种通信方式各有优缺点。这部分主要就进程间通信方式进行总结。 1 信号。 信号进行进程间通信方式有一点需要明确：信号只能通知，不能在进程间共享数据资源。也就是说信号仅仅是告诉你一下某个事情发生了。而我们的程序则可以对这个信号进行各种我们自定义或者默认的处理，更或者当做没有听见。 那么既然是通知一件事情发生
进程间通信-信号
xurongxin2006的博客
10-19 1358
信号是进程间通信方式；信号是唯一的一种异步通信方式；是软件层次上中断模拟。1、信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。2、信号可以在进程与进程之间，内核与进程之间产生。3.、信号可以被阻塞，可以延迟送达，但信号不会丢失。
【Linux】进程间通信：信号
W__winter的博客
05-18 789
2、信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来 通知 用户空间进程发生了哪些系统事件。5.2.3中，提到了可以用子进程在退出的时候，给父进程发送一个SIGCHLD信号，来回收僵尸进程。3、如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递给它。4、如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。自定义信号处理函数，当信号发生的时候，立即执行自定义信号处理函数。3、执行缺省操作（执行默认操作）
进程间通信信号
LCH的博客
03-06 653
进程间通信--信号信号：是有系统内核发出的由于错误内存冲突等原因引起产生的，主要用于控制进程。1.信号可以被生成捕获响应。常见的有SIGCHLD SIGCHINT2.响应方式有三种（忽略SIG_IGN）（默认SIG_DFL）（自定义fun）fun是自定义函数指针fun（int sig）接下来的函数会为我们的自定义函数传递信号值头文件#include&lt;signal.h&gt; int si...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YoungerChina

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

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

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

打赏作者

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

抵扣说明：

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

余额充值