进程间通信--信号(进程间通信唯一的异步方式)

最新推荐文章于 2023-10-16 18:38:36 发布
最新推荐文章于 2023-10-16 18:38:36 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： Linux环境/环境编程 文章标签： Linux signal

转载地址：

http://blog.chinaunix.net/uid-25120309-id-3301181.html向原作者致敬^ _ ^


正文：

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

一、信号的介绍

信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。
信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了那些系统事件。
如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递个它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞取消时才被传递给进程。

二、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.通过系统调用向一个指定的进程发送信号 
#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);
参数说明:
第一个参数：指定发送信号的接收线程
第二个参数：信号的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;
}
运行结果如下:
 
[root@zx signal]# ./a.out 
19
Warning: bad syntax, perhaps a bogus '-'? See /usr/share/doc/procps-3.2.7/FAQ
root      8313  0.0  0.0   1732   364 pts/1    S+   19:50   0:00 ./a.out
root      8314  8.7  0.0   1728    72 pts/1    T+   19:50   0:00 ./a.out
root      8315  0.0  0.1   6208  1012 pts/1    S+   19:50   0:00 sh -c ps -aux | grep a.out
root      8317  0.0  0.1   5612   744 pts/1    S+   19:50   0:00 grep a.out
9
Warning: bad syntax, perhaps a bogus '-'? See /usr/share/doc/procps-3.2.7/FAQ
root      8313  0.0  0.0   1732   364 pts/1    S+   19:50   0:00 ./a.out
root      8314  5.0  0.0      0     0 pts/1    Z+   19:50   0:00 [a.out] <defunct>
root      8318  0.0  0.1   6208  1012 pts/1    S+   19:50   0:00 sh -c ps -aux | grep a.out
root      8320  0.0  0.1   5612   740 pts/1    S+   19:50   0:00 grep a.out
18
Warning: bad syntax, perhaps a bogus '-'? See /usr/share/doc/procps-3.2.7/FAQ
root      8313  0.0  0.0   1732   364 pts/1    S+   19:50   0:00 ./a.out
root      8314  1.9  0.0      0     0 pts/1    Z+   19:50   0:00 [a.out] <defunct>
root      8321  0.0  0.1   6208  1016 pts/1    S+   19:51   0:00 sh -c ps -aux | grep a.out
root      8323  0.0  0.1   5612   744 pts/1    S+   19:51   0:00 grep a.out
^C
[root@zx signal]#


B.捕捉一个信号

对应的API 
       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);
其原型:
 
       typedef void (*sighandler_t)(int);
参数说明:
signum  :  指定信号
handler  :  SIG_IGN忽略该信号，SIG_DFL采用系统默认方式处理信号,自定义的信号处理函数指针。

案例探究:

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

注意：子进程在终止时会给父进程发SIGCHLD，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需要专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。 
#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);
}

C.闹钟函数alarm 
       #include <unistd.h>

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

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

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

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

......

alarm(5);

出错:-1

案例探究: 
#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;
}

案例二、综合案例

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

clientA:（与clientB只是在对fifo a和b的调用上相反） 
#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);
}

client B
 
#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);
}

D.将进程挂起函数pause
 
       #include <unistd.h>

       int pause(void);
解释如下:
The  pause()  library function causes the invoking process (or thread) to sleep until a signal is received that either terminates it or causes it to call a signal-catching function.

PS:(利用signal模拟中断)

利用signal可以在用户态实现简单的中断：如主进程在执行一项工作，但是主进程希望某一文件非空的时候立马处理其他工作，这个和硬件中断很相似
其实，这个就可以用signal来实现：主进程开一个子进程用来阻塞读取指定文件，若非空，则向父进程发送kill()命令，以通知其异步工作,而父进程处理signal的handler函数之后还会返回之前的调用点继续工作，这个和硬件中断真是很像！
linux下模拟这个硬件中断很方便哦~^ _ ^

forsakening
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程间通信方式（二）-- 信号通信
ぃ未来可期
10-06 435
信号通信1. 概念2. 信号对进程的默认处理方式3. 修改信号对进程的处理方式4. 常用信号及处理方式5. 信号相关函数5.1 signal()5.2 kill() / raise()5.3 pause() 阻塞等待一个信号产生5.4 alarm() 定时产生SIGALRM信号6. 管道只写不读，修改信号处理方式7. 使用信号处理僵尸进程 1. 概念 互斥：同一时间只能有一个进程或者线程运行 同步：在互斥的基础上有顺序执行 异步：在执行一个程序过程中，打断当前进程执行另一个程序，执行完毕后接着之前的代码继续
进程之间的通信方式
Emine
09-03 6270
进程间通信方式一般有以下几种： 1、管道，匿名管道，命名管道 2、信号 3、信号量 4、消息队列 5、共享内存 6、socket 管道 管道数据只能单向流动，所以如果要实现双向通信，就要创建2个管道 管道分为匿名管道和命名管道 匿名管道只能在父子进程关系之间使用 命名管道，可以在不关联的两个进程之间使用，因为它创建了一个类型为管道的设备文件，使用这个设备文件就可以通信。 管道只能承载无格式的字节流 信号 信号是进程之间唯一的异步通信机制，信号的主要来源主要有硬件来源（入键盘操作ctrl + C）
进程间的 信号 通信
ZhY_Rening的博客
12-22 457
进程间的 信号 通信
进程间通信与信号基础
weixin_55530858的博客
10-13 332
进程通信 管道 信号基础函数 alarm signal pause 中断
进程通信、同步和异步
g498912529的博客
07-22 1823
进程间通讯的7种方式、进程线程同步划分的总结记录
进程间方便的通信—信号
dongdong7_77的博客
12-17 215
前言 在计算机科学中，信号是Unix、类Unix以及其他POSIX兼容的操作系统中进程间通讯的一种有限制的方式。它是一种异步的通知机制，用来提醒进程一个事件已经发生。当一个信号发送给一个进程，操作系统中断了进程正常的控制流程，此时，任何非原子操作都将被中断。如果进程定义了信号的处理函数，那么它将被执行，否则就执行默认的处理函数。 信号的定义 信号是软件中断，信号的响应依赖于中断，信号会通过去扎内核...
Linux进程间的通信方式和原理
01-27
普通管道和流管道是单工的，用于父子进程或兄弟进程间通信；命名管道则允许非相关进程间通信，支持双向传输。 2. **信号量(Semaphore)**: 信号量是一个计数器，用于多进程对共享资源的访问控制，实现同步和互斥，...
Linux进程间通信-消息队列实例.pdf
07-11
在Linux系统中，提供了多种进程间通信方式，如管道、信号量、共享内存、套接字等。其中，消息队列是一种可靠且灵活的数据交换方式，它允许进程之间发送结构化数据。 消息队列的主要特点： 1. **持久性**：消息队列...
5种进程间通信（IPC）技术
最新发布
10-31
进程间通信（IPC，Inter-Process Communication）是操作系统中一种重要的机制，允许不同的进程之间交换信息，协同工作。本文将详细介绍五种常见的IPC技术：消息队列、共享内存、信号量、管道和FIFO。 首先，消息...
利用信号进行进程间通信
12-15
利用信号进行进程间通信：实现一个SIGINT信号的处理程序，注册该信号处理程序，创建一个子进程，父子进程都进入等待。
自定义消息实现进程通信
09-15
自定义消息实现进程通信 使用ＭＦＣ模拟实现进程间的通信，一个发送程序，一个接受程序，两个进程实现。
IPC之使用Socket进程间通信
11-02
使用Socket来实现跨进程间的通信
浅谈Linux进程间通信方式及优缺点
09-15
本文将详细探讨几种常见的Linux进程间通信方式及其优缺点。 首先，管道（Pipe）是最早也是最简单的进程间通信方式之一。管道分为有名管道（ Named Pipe）和无名管道（Unnamed Pipe）。无名管道是一种半双工通信方式...
FIFO.rar_进程间通信
09-14
在计算机科学领域，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的一种方式。FIFO，全称为先进先出（First In First Out），是Unix/Linux系统中实现进程间通信的一种机制，它...
linux用信号写代码,linux中l通过自定义信号完成进程间的通信的代码
weixin_39626369的博客
05-12 306
信号同样是用于进程通信的，他是一种异步通信方式。我们之前的管道不是，明显，读进程要等管道里面有数据才能运行，否则他要等待。信号处理则不同，进程不知道什么时候信号会到来，先看一小段代码，看看信号的程序：[root@liumengli signal]# cat ./signal_recive1.c#include "stdio.h"#include "signal.h"#include "sys/ty...
编程同步与异步、进程与线程、进程间通信具体分析、线程同步与互斥具体分析、五种io模型具体分析
m0_46376834的博客
10-16 372
编程中的同步和异步是两种不同的执行模式，它们涉及到代码如何执行和处理任务的方式。同步（Synchronous）指的是代码按照顺序依次执行，每一步执行完成后再进行下一步。在同步模式下，当一个任务被调用后，程序会等待这个任务的完成才会继续执行后面的任务。同步模式适合于需要按照特定顺序执行任务，且需要等待任务结果的情况。异步（Asynchronous）指的是代码执行时不需要等待任务的完成，而是继续执行后面的代码。在异步模式下，当一个任务被调用后，程序不会等待该任务的完成，而是继续执行下一个任务。
Linux进程间通信——使用信号
haierboos
08-21 742
一、什么是信号 用过Windows的我们都知道，当我们无法正常结束一个程序时，可以用任务管理器强制结束这个进程，但这其实是怎么实现的呢？同样的功能在Linux上是通过生成信号和捕获信号来实现的，运行中的进程捕获到这个信号然后作出一定的操作并最终被终止。 信号是UNIX和Linux系统响应某些条件而产生的一个事件，接收到该信号的进程会相应地采取一些行动。通常信号是由一个错误产生的。但它们还可...
第4章 System V的进程间通信1
08-03
"本章主要探讨System V的进程间通信机制，包括消息队列、信号量和共享主存。实验旨在让读者理解System V IPC的工作原理，并熟练掌握使用这些通信方式来实现进程间的同步和通信。" System V的进程间通信（IPC）是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值