进程间通信，无名管道pipe，有名管道mkfifo，信号的基础概念，signal函数

已于 2024-02-29 09:22:49 修改
阅读量733 收藏 29
点赞数 16
文章标签： linux vim 进程间通信 管道 信号
于 2024-02-28 17:26:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71850179/article/details/136339700
版权

我要成为嵌入式高手之2月28日Linux高编第十一天！！

学习笔记 

进程间通信

总共6种通信方法，主要是前五种方式

第一种方式：管道

一、无名管道

只能用于具有亲缘关系的进程间通信

pipe

#include <unistd.h>

int pipe(int pipefd[2]);

功能：创建一个无名管道

参数：

        pipefd[0]：读

        pipefd[1]：写

返回值：成功返回0；失败返回-1

#include "head.h"

int main(void)
{
    pid_t pid;
    int fd[2];
    int ret;
    char tmpbuff[4096];

    ret = pipe(fd);
    if (ret == -1)
    {
        perror("fail to pipe");
        return -1;
    }

    pid = fork();
    if (pid == -1)
    {
        perror("fail to fork");
        return -1;
    }
    if (pid == 0)
    {
        strcpy(tmpbuff, "hello world!");
        write(fd[1], tmpbuff, strlen(tmpbuff));
    }
    else if (pid > 0)
    {
        read(fd[0], tmpbuff, sizeof(tmpbuff));//read有等待作用，若文件标识符内没有可读内容，会等待到有可读内容
        printf("tmpbuff = %s\n", tmpbuff);
    }
    close(fd[0]);
    close(fd[1]);

    return 0;
}

 

无名管道的特性：

1、管道中至少有一个写端：

        读取数据时如果有数据直接读取；管道中没有数据，阻塞等待直到有数据写入，然后读出，继续向后执行 。

2、管道中没有写端：

        读取数据时，如果管道中有数据直接读取，管道中没有数据不阻塞等待直接向下执行

3、管道中至少有一个读端：

        写入数据时，如果管道中没有存满则直接写入，如果管道中存满则阻塞等待，直到有数据读出才继续写入

4、管道中没有读端：

        写入数据时，会产生管道破裂的错误，导致程序崩溃

二、有名管道

操作方式：

        打开管道文件（open）--->读写（read，write）管道文件--->关闭（close）管道文件

特性：有名管道必须读写两端同时加入才能继续向下执行

1、mkfifo

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

功能：创建一个管道文件

参数：

        pathname：管道文件的路径（名字包含在路径里）

        mdoe：权限（0777、0664）

返回值：成功返回0，失败返回-1；

练习：编写两个进程A B, A给B发送一条消息，B收到消息打印后给A回复一条消息

注：在接收函数之前都加入memset

#include "head.h"

int main(void)
{
    int fatob = 0;
    int fbtoa = 0;
    char tmpbuff[1024] = {0};

    mkfifo("/tmp/ATOB", 0777);
    mkfifo("/tmp/BTOA", 0777);

    fatob = open("/tmp/ATOB", O_WRONLY);
    if (fatob == -1)
    {
        perror("fail to open1");
        return -1;
    }

    fbtoa = open("/tmp/BTOA", O_RDONLY);
    if (fbtoa == -1)
    {
        perror("fail to open2");
        return -1;
    }

    while (1)
    {
        memset(tmpbuff, 0, sizeof(tmpbuff));
        gets(tmpbuff);
        write(fatob, tmpbuff, strlen(tmpbuff));

        memset(tmpbuff, 0, sizeof(tmpbuff));
        read(fbtoa, tmpbuff, sizeof(tmpbuff));
        printf("RECV:  %s\n", tmpbuff);
    }
    close(fatob);
    close(fbtoa);

    return 0;
}

#include "head.h"

int main(void)
{
    int fatob = 0;
    int fbtoa = 0;
    char tmpbuff[1024] = {0};

    mkfifo("/tmp/ATOB", 0777);
    mkfifo("/tmp/BTOA", 0777);

    fatob = open("/tmp/ATOB", O_RDONLY);
    if (fatob == -1)
    {
        perror("fail to open1");
        return -1;
    }

    fbtoa = open("/tmp/BTOA", O_WRONLY);
    if (fbtoa == -1)
    {
        perror("fail to open2");
        return -1;
    }

    while (1)
    {
        memset(tmpbuff, 0, sizeof(tmpbuff));
        read(fatob, tmpbuff, sizeof(tmpbuff));
        printf("RECV:  %s\n", tmpbuff);
     
        memset(tmpbuff, 0, sizeof(tmpbuff));
        gets(tmpbuff);
        write(fbtoa, tmpbuff, strlen(tmpbuff));
    }
    close(fatob);
    close(fbtoa);

    return 0;
}

 进阶难版

#include "head.h"

pthread_t tid1;
pthread_t tid2;

void *Write(void *arg)
{
  
    int fatob = 0;
    char tmpbuff[1024] = {0};

    while (1)
    {
        mkfifo("/tmp/ATOB", 0777);
        fatob = open("/tmp/ATOB", O_WRONLY);
        if (fatob == -1)
        {
            perror("fail to open1");
            return NULL;
        }

        memset(tmpbuff, 0, sizeof(tmpbuff));
        gets(tmpbuff);
        write(fatob, tmpbuff, strlen(tmpbuff));
        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        close(fatob);
    }
    pthread_cancel(tid2);

    return NULL;
}

void *Read(void *arg)
{
    int fbtoa;
    char tmpbuff[1024] = {0};

    while (1)
    {
        mkfifo("/tmp/BTOA", 0777);
        fbtoa = open("/tmp/BTOA", O_RDONLY);
        if (fbtoa == -1)
        {
            perror("fail to open2");
            return NULL;
        }

        memset(tmpbuff, 0, sizeof(tmpbuff));
        read(fbtoa, tmpbuff, sizeof(tmpbuff));
        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        
        printf("RECV:  %s\n", tmpbuff);
        close(fbtoa);
    }
    pthread_cancel(tid1);

    return NULL;
}

int main(void)
{
    int ret1 = 0;
    int ret2 = 0;

    ret1 = pthread_create(&tid1, NULL, Write, NULL);
    if (ret1 != 0)
    {
        perror("fail to tid1");
        return -1;
    }
    ret2 = pthread_create(&tid2, NULL, Read, NULL);
    if (ret2 != 0)
    {
        perror("fail to tid2");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

#include "head.h"

pthread_t tid1;
pthread_t tid2;

void *Write(void *arg)
{
  
    int fbtoa = 0;
    char tmpbuff[1024] = {0};

    while (1)
    {
        mkfifo("/tmp/BTOA", 0777);
        fbtoa = open("/tmp/BTOA", O_WRONLY);
        if (fbtoa == -1)
        {
            perror("fail to open1");
            return NULL;
        }

        memset(tmpbuff, 0, sizeof(tmpbuff));
        gets(tmpbuff);
        write(fbtoa, tmpbuff, strlen(tmpbuff));
        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        close(fbtoa);
    }
    pthread_cancel(tid2);

    return NULL;
}

void *Read(void *arg)
{
    int fatob;
    char tmpbuff[1024] = {0};

    while (1)
    {
        mkfifo("/tmp/ATOB", 0777);
        fatob = open("/tmp/ATOB", O_RDONLY);
        if (fatob == -1)
        {
            perror("fail to open2");
            return NULL;
        }

        memset(tmpbuff, 0, sizeof(tmpbuff));
        read(fatob, tmpbuff, sizeof(tmpbuff));
        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        printf("RECV:  %s\n", tmpbuff);
        close(fatob);
    }
    pthread_cancel(tid1);

    return NULL;
}

int main(void)
{
    int ret1 = 0;
    int ret2 = 0;
   

    ret1 = pthread_create(&tid1, NULL, Write, NULL);
    if (ret1 != 0)
    {
        perror("fail to tid1");
        return -1;
    }
    ret2 = pthread_create(&tid2, NULL, Read, NULL);
    if (ret2 != 0)
    {
        perror("fail to tid2");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

第二种方式：信号

信号用来实现内核层和用户层信息的交互，也可以用来实现进程间通信

一、信号的种类

kill -l来查看

1) SIGHUP（挂起）     

2) SIGINT（中断）     

3) SIGQUIT（退出）     

4) SIGILL    

5) SIGTRAP

6) SIGABRT（产生异常）     

7) SIGBUS（总线错误）     

8) SIGFPE    

9) SIGKILL（杀死信号）   

10) SIGUSR1

11) SIGSEGV（段错误）   

12) SIGUSR2    

13) SIGPIPE（管道破裂）   

14) SIGALRM（定时时间到了）   

15) SIGTERM

16) SIGSTKFLT    

17) SIGCHLD（一个子进程结束，给父进程发送的信号）   

18) SIGCONT（让进程继续执行）   

19) SIGSTOP（让进程挂起）   

20) SIGTSTP（让进程挂起）

21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) SIGXCPU    25) SIGXFSZ

26) SIGVTALRM    27) SIGPROF    28) SIGWINCH    29) SIGIO（异步IO）    30) SIGPWR

31) SIGSYS    34) SIGRTMIN    35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3

38) SIGRTMIN+4    39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    

42) SIGRTMIN+8    43) SIGRTMIN+9    44) SIGRTMIN+10    45) SIGRTMIN+11    

46) SIGRTMIN+12    47) SIGRTMIN+13    48) SIGRTMIN+14    49) SIGRTMIN+15    

50) SIGRTMAX-14    51) SIGRTMAX-13    52) SIGRTMAX-12    53) SIGRTMAX-11    

54) SIGRTMAX-10    55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7

58) SIGRTMAX-6    59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    

62) SIGRTMAX-2    63) SIGRTMAX-1    64) SIGRTMAX    

所有的信号都可以让进程结束

二、信号处理方式

1、缺省：

        按照系统默认的方式处理

2、忽略：

        不响应信号

3、捕捉：

        按照自己设定的方式处理信号

注意：

        9号信号（杀死）和19号信号（暂停）不可被忽略和捕捉，即只能按照缺省的方式处理

可键入：

        SIGINT：ctrl + c

        SIGQUIT：ctrl + \

        SIGTSTP：ctrl + z

4、signal

#include <signal.h>

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

功能：改变信号的处理方式

参数：

        signum：信号的编号

        handler：信号的处理方式

                SIG_IGN        忽略处理

                SIG_DFL        缺省处理

                函数首地址     捕捉处理

返回值：

        成功返回之前处理函数的首地址

        失败返回SIG_ERR

练习：

#include "head.h"

void handler1(int signo)
{
    printf(" SIGINT信号来了!\n");
    
    return;
}

void handler2(int signo)
{
    printf(" SIGQUIT信号来了!\n");
    
    return;
}

void handler3(int signo)
{
    printf(" SIGTSTP信号来了!\n");
    
    return;
}

int main(void)
{
    signal(SIGINT, handler1);
    signal(SIGQUIT, handler2);
    signal(SIGTSTP, handler3);

    while (1)
    {

    }

    return 0;
}

7.25！
关注
  • 16
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
无名管道和有名管道
Ccccspring的博客
08-10 2290
进程间的通信，管道字如其名，它就像在两个进程之间铺设了一条管道，进程通过管道进行数据交互。可以发现，从write_fifo里输入的值，read_fifo那里也输出了，说明fifo管道将他们连通了，可以传输数据。可以看到，当size=65536时，就不动了，说明管道写满了，大小为65536，当然，可能不同系统大小有所差异。可以看到WIFEXITED(status)的结果是0，说明为非正常退出，而程序也正常运行，所有就是管道破裂了。创建一个有名管道，一个进程向管道中输入数据，另一个进程输出数据。...
实验五-进程间通信实验(二).doc
11-17
通过本实验，我们了解了进程间通信的两种方式：无名管道和有名管道，并学习了如何使用 pipe 函数和 mkfifo 函数来创建管道，以及如何使用 open 函数来打开和读写管道。此外，我们还学习了信号处理机制如何在进程间...
一、无名管道
weixin_57886538的博客
01-17 675
无名管道概述 管道(pipe)又称无名管道。无名管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。任何一个进程在创建的时候，系统都会给他分配4G的虚拟内存，分为3G的用户空间和1G的内核空间，内核空间是所有进程公有的，无名管道就是创建在内核空间的，多个进程知道同一个无名管道的空间，就可以利用他来进行通信
【无名管道】无名管道（Pipe）与进程通信：快速上手
crr411422的博客
06-28 887
无名管道是一种强大且基础的进程间通信机制，它使得具有亲缘关系的进程之间能够方便地共享数据。无名管道的使用，无论是在简单的Shell命令，还是在复杂的多进程应用中，都有着广泛的应用。 注意：无名管道只能在具有公共祖先的进程之间使用，且只能实现单向通信。
IO - 进程间通信
最新发布
weixin_67273669的博客
04-20 1139
进程间通信，无名管道，有名管道，信号，共享内存，信号灯集，消息队列
无名管道 / 有名管道(FIFO)
mjmmm的博客
08-15 490
根据上节所讲就可以了解到：管道其实就是实现进程间通讯IPC中的一种类型方法。
又名管道和无名管道
qq_43341187的博客
05-31 909
4.对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。
进程间软中断通信和管道通信
12-02
为了实现上述的进程间软中断通信和管道通信，开发者需要具备扎实的Linux编程基础，了解信号处理、文件I/O和进程控制等概念。在实际应用中，还需要考虑同步和互斥问题，以避免数据竞争和死锁等并发问题。例如，使用`...
7_pipe_signal.rar
01-17
在Linux系统编程中，管道（Pipe）和信号（Signal）是两个重要的概念，它们是进程间通信（IPC, Inter-Process Communication）的方式之一。而定时器（Timer）则用于设置程序执行过程中的时间间隔，以实现特定的定时...
进程间通信
07-23
- 无名管道：使用`pipe()`函数创建，只能在具有亲缘关系的进程（通常是父子进程）之间通信。`fd[0]`为读端，`fd[1]`为写端。代码中，父进程关闭写端，子进程关闭读端，然后通过管道进行数据传输。 4. **有名管道...
Linux系统编程实验六：进程间通信.doc
09-25
本实验的目的是学会进程间通信的方式，包括无名管道、有名管道、信号、消息队列等。下面我们将详细介绍每种方式的实现。 一、无名管道 无名管道是一种半双工的通信方式，即只能单向传输数据，不能双向传输数据。...
有名管道和无名管道
qq_36091214的博客
05-16 552
概念：就是进程和进程之间交换信息。常用通信方式无名管道（pipe）有名管道 （fifo）信号（signal）共享内存(mmap)套接字（socket）过时的IPC通信方式共享内存（share memory）消息队列（message queue）信号灯集（semaphore set）
Linux进程编程（2）进程间管道通信之无名管道
weixin_53122643的博客
08-01 410
管道（Pipe）是一种用于进程间通信的机制，在Unix和类Unix系统中广泛使用。它允许一个进程将数据写入到管道中，而另一个进程则可以从管道中读取这些数据。管道通常用于在父进程和子进程之间传递数据。管道有两种类型：有名管道（Named Pipe）和无名管道（Unnamed Pipe）。在这里，我们主要讨论无名管道，因为在本篇文章中使用的就是无名管道。无名管道是一种匿名的、单向的通信通道。它只能在有亲缘关系（父子关系）的进程之间使用，因为无名管道在创建时并没有名字，只存在于相应的进程内部。
进程间通信-无名管道，有名管道，信号
蒲公英的诗与远方
03-18 849
目录进程进程间通信 进程 （一） 进程间通信 （一）进程间通信几种方式 （1）管道 （2）信号
无名管道、有名管道
qq_53090814的博客
09-01 157
无名管道只能用于具有亲缘关系的进程之间的通信，即父进程创建子进程后，它们之间可以通过无名管道进行通信。与无名管道不同，有名管道在文件系统中有一个相关的路径名，并且可以通过该路径名在不同的进程之间进行通信。需要注意的是，创建的有名管道既可以被读取进程打开，也可以被写入进程打开。总结来说，无名管道用于具有亲缘关系的进程之间的单向通信，而有名管道用于不具有亲缘关系的进程之间的双向通信，并且有一个相关的路径名。- 管道的大小是有限的，一旦管道被填满，写入进程将被阻塞，直到有进程读取管道中的数据。
Linux基础：有名管道和无名管道
weixin_58368590的博客
06-01 4506
有名管道和无名管道，代码实现，面试常问试题
Linux进程间通信：无名管道(pipe)，有名管道(fifo)
m0_74985965的博客
01-19 570
进程与进程在应用层里面不能直接进行信息交互，必须通过内核来进行通信。 创建一个管道作为进程间信息交互的媒介，所以进程A就可以在管道中写入数据，进程B在从管道中读取数据，这样就可以实现进程A与进程B之间的通信 ①只适用于带有亲缘关系的进程，比如父子进程；如果进程间没有任何关系，就不能使用无名管道。②只能实现一个进程写另一个进程读，而如果需要两者同时进行时，就得重新打开一个管道。①可以实现没有任何亲缘关系的进程间的通信，因为有名管道在使用前必须创建一个特殊文件名(mkfifo)来承接进程间的读和写；
pipe管道
超哥的专栏
06-26 571
进程I/OFILE *popen(const char *command, const char *type);创建一个管道，调用 fork 产生一个子进程，执行一个 shell 以运行命令来开启一个进程 type： 如果 type 是 “r” 则文件指针连接到 command 的标准输出；如果 type 是 “w” 则文件指针连接到 command 的标准输入 command： 一个指向以
吉林大学研究所课程-并行计算课件-第8章-进程通信.ppt
10-19
该章节涵盖了多种进程通信机制，包括信号、管道（无名管道和命名管道）、消息队列、信号灯、共享内存以及内存映射文件。 1. 无名管道（Pipe） - 无名管道是一种半双工通信方式，即一次只能有一个方向的数据传输。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值