进程间通信之匿名管道通信

最新推荐文章于 2024-04-10 23:05:24 发布
最新推荐文章于 2024-04-10 23:05:24 发布
阅读量991 收藏
点赞数 1
分类专栏： Linux应用编程 文章标签： unix 数据 内核 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzjsqn/article/details/53844480
版权

概念

  • 管道是Unix中最古老的进程间通信的形式。

  • 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”
    比如：eg: ls | wc -l ps –u wbm01|grep “aa”

  • 管道的本质====》固定大小的内核缓冲区

  • 管道限制
    • 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道
    • 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。

匿名管道pipe

  • 包含头文件<unistd.h>
  • 功能:创建一无名管道
  • 原型
    int pipe(int fd[2]);
  • 参数
    fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
  • 返回值:成功返回0，失败返回错误代码

管道创建后示意图

这里写图片描述

这里写图片描述

管道的读写规则

  • 当没有数据可读时
    • O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
    • O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
  • 当管道满的时候
    • O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
    • O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
  • 如果所有管道写端对应的文件描述符被关闭，则read返回0
  • 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE
  • 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。
  • 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

示例代码

  • 默认阻塞读和SIGPIPE写
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

#define ERR_EXIT(m) \
    do \
    { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)


int main(void )
{
    int pipefd[2];
    pid_t pid;

    //创建管道文件，并打开
    if (pipe(pipefd) == -1 )    
    {
        printf("pipe() err..\n");   
        return -1;
    }
    pid = fork();
    if (pid == -1)
    {
        printf("fork err..\n");
        return -1;
    }

    if (pid == 0)
    {
        close(pipefd[0]);
        write(pipefd[1], "hello hello....", 6);
        close(pipefd[1]);
        printf("child .....quit\n");
      exit(0);
    } 
    else if (pid > 0 )
    {
        int len = 0; 
        char buf[100] = {0};
        close(pipefd[1]);
        len = read(pipefd[0], buf, 100);
        printf("len:%d, buf:%s \n", len , buf);

        close(pipefd[0]);
    }

    wait(NULL);
    printf("parent ..quit\n");
    return 0;

}
  • 使用fcntl修改为非阻塞模式
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

#define ERR_EXIT(m) \
    do \
    { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)


//非阻塞场景
int main(void )
{
    int ret = 0;
    int pipefd[2];

    ret = pipe(pipefd);
    if (ret < 0)
    {
        perror("ddd");
        exit(0);
    }
    int pid; 
    pid = fork();
    if (pid == -1)
    {
        perror("dd");
        exit(0);
    }

    if (pid == 0) //子进程
    {
        close(pipefd[0]);
        sleep(5);
        write(pipefd[1], "childaaaaaaaaa", 6 );
        printf("chile quit\n");
        close(pipefd[1]);
        exit(0);
    }

    close(pipefd[1]);
    char readbuf[1000] = {0};
    int n = 0;

    int flags = fcntl(pipefd[0], F_GETFL);
    flags = flags | O_NONBLOCK;
  ret = fcntl(pipefd[0], F_SETFL, flags);
  if (ret == -1)
  {
    printf("fcntl err.\n");
    exit(0);
  }

    n = read(pipefd[0], readbuf,sizeof(readbuf));
    if (n < 0)
    {
        printf("read no block--return right now\n");
    }
    printf("%s\n", readbuf);
    close(pipefd[0]);

    wait(NULL);

    printf("parent quit\n");

  return 0;
}
  • 所有的写端都关闭–read返回0,并非错误
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

#define ERR_EXIT(m) \
    do \
    { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)


int main(void )
{
    int ret = 0;
    int pipefd[2];

    ret = pipe(pipefd);
    if (ret < 0)
    {
        perror("ddd");
        exit(0);
    }
    int pid; 
    pid = fork();
    if (pid == -1)
    {
        perror("dd");
        exit(0);
    }

    if (pid == 0) //子进程
    {
        close(pipefd[0]);//关闭子进程的读端

        close(pipefd[1]);//关闭子进程的写端
        exit(0);
    }

    close(pipefd[1]);关闭父进程的写端
    char readbuf[1000] = {0};
    int n = 0;
    sleep(3);//保证子进程先结束--确保所有的写端都关闭

    n = read(pipefd[0], readbuf,sizeof(readbuf));
    printf("all write port closed,num of read:%d \n", n);

    printf("%s\n", readbuf);
    close(pipefd[0]);

    wait(NULL);

    printf("parent quit\n");
  return 0;
}
  • 两端的读都被关闭，写操作会发生一个错误信号 SIGPIPE 管道断开的错误信号
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

#define ERR_EXIT(m) \
    do \
    { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

void myhandle(int sig)
{
    printf("recv sig:%d \n", sig);
}
//演示管道两端的读都被关闭，写操作会发生一个错误信号 SIGPIPE 管道断开的错误信号
int main(void )
{
    int pipefd[2];
    pid_t pid;

    //注册管道处理函数
    signal(SIGPIPE, myhandle);

    if (pipe(pipefd) == -1 )    
    {
        printf("pipe() err..\n");   
        return -1;
    }
    pid = fork();
    if (pid == -1)
    {
        printf("fork err..\n");
        return -1;
    }

    if (pid == 0)
    {
        close(pipefd[0]);  //关闭子进程读端
        printf("child .....quit\n");
        exit(0);
    } 
    else if (pid > 0 )
    {
        int len = 0; 

        close(pipefd[0]); //关闭父进程读端

        //父进程sleep 1s后，再读
        sleep(1);

        len = write(pipefd[1], "wangbaomingwangbaoming", 6); 
        //会有信号发生（异步通知事件发生）言外之意主程序可以随时被打断
        //有了信号，就可以支持这种机制
        if (len == -1)
        {
            printf("两端的读都关闭，会发送信号，然后再执行这句话 :%d \n", len);
        }
    }

    wait(NULL);//避免僵尸进程
    printf("parent ..quit\n");
    return 0;

}
  • 测试管道容量
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
//测试管道容量

#define ERR_EXIT(m) \
    do \
    { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)


void myhandle(int sig)
{
    printf("recv sig:%d \n", sig);
}


int main(void )
{
    int pipefd[2];
    pid_t pid;

    //注册管道处理函数
    signal(SIGPIPE, myhandle);

    if (pipe(pipefd) == -1 )    
    {
        printf("pipe() err..\n");   
        return -1;
    }

    pid = fork();
    if (pid == -1)
    {
        printf("fork err..\n");
        return -1;
    }

    if (pid == 0)
    {
        int count = 0;
        int ret = 0;
        close(pipefd[0]);


        //写端变成非阻塞
        int flags = fcntl(pipefd[1], F_GETFL);
        flags = flags | O_NONBLOCK;
        ret = fcntl(pipefd[1], F_SETFL, flags);
        if (ret == -1)
        {
            printf("fcntl err.\n");
            exit(0);
        }

        while(1)
        {
            ret = write(pipefd[1] , "a", 1);    //，非阻塞模式下：写满的时候再继续写入会立即返回-1
            if (ret == -1)
            {
                perror("write pipe");
                break;
            }
            count ++;   
        }

        printf("count:%d \n\n", count);
        close(pipefd[1]);
        exit(0);
    } 
    else if (pid > 0 )
    {

        sleep(4);
        close(pipefd[0]);
        close(pipefd[1]);
    }

    wait(NULL);
    printf("parent ..quit\n");
    return 0;
}
  • 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>


#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)

#define TEST_SIZE 68*1024   //68K


int main(void)
{
    char a[TEST_SIZE];
    char b[TEST_SIZE];

    memset(a, 'A', sizeof(a));
    memset(b, 'B', sizeof(b));

    int pipefd[2];

    int ret = pipe(pipefd);
    if (ret == -1)
        ERR_EXIT("pipe error");

    pid_t pid;
    pid = fork();
    if (pid == 0) //A子进程写68K数据A
    {
        close(pipefd[0]);
        ret = write(pipefd[1], a, sizeof(a));
        printf("apid=%d write %d bytes to pipe\n", getpid(), ret);
        exit(0);
    }

    pid = fork();


    if (pid == 0) //B子进程写68K数据B
    {
        close(pipefd[0]);
        ret = write(pipefd[1], b, sizeof(b));
        printf("bpid=%d write %d bytes to pipe\n", getpid(), ret);
        exit(0);
    }


    close(pipefd[1]);

    sleep(1);
    int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    char buf[1024*4] = {0};
    int n = 1;
    while (1)
    {
        //父进程4k 4k的读数据，发现AB进程是交叉的写数据到管道。
        //多个进程往管道里面，写数据。
        ret = read(pipefd[0], buf, sizeof(buf)); 
        if (ret == 0)
            break;
        printf("n=%02d pid=%d read %d bytes from pipe buf[4095]=%c\n", n++, getpid(), ret, buf[4095]);
        write(fd, buf, ret);

    }
    return 0;   
}
  • 管道概念再深入–模仿ls | wc -w
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/wait.h>


#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)

#define TEST_SIZE 68*1024   //68K


int main(void )
{
    int pipefd[2];
    pid_t pid;
    if (pipe(pipefd) == -1 )    
    {
        printf("pipe() err..\n");   
        return -1;
    }
    pid = fork();
    if (pid == -1)
    {
        printf("fork err..\n");
        return -1;
    }
    if (pid == 0)
    {
        close(pipefd[0]);
        //复制文件描述符pipefd[1]，给标准输出，言外之意：execlp的ls命令输出到管道中
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[1]);

        execlp("ls", "ls", NULL);
        //如果替换新的进程印象失败，则会执行下面一句话    
        fputs("execute the cmd ls err..\n",stderr);
        exit(0);        
    } 
    else if (pid > 0 )
    {
        int len = 0; 
        char buf[100] = {0};
        close(pipefd[1]);
        //复制文件描述符pipefd[0]，给标准输入，言外之意：execlp的wc命令从管道中读
        dup2(pipefd[0], STDIN_FILENO);
        close(pipefd[0]);

        execlp("wc", "wc", "-w", NULL);
        printf("len:%d, buf:%s \n", len , buf);
    }

  wait(NULL);
    printf("parent ..quit\n");
    return 0;

}
小帅比simon
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程间通信之匿名管道
shine_zyd_way的博客
08-14 472
我们知道每个进程都有各自 的进程地址空间，一个进程看不到另外一个进程的全局变量，那么要实现进程之间的数据交换，必须要通过内核，首先内核要先开辟缓冲区，进程1先把数据拷贝到内核的缓冲区中，进程2再从缓冲区中把数据拿走，内核提供的这种机制就叫做进程间通信。 管道是一种基本的IPC机制，用于创建管道的函数为pipe;#include <unistd.h> int pipe(int filedes[2])
进程间的通信方式之管道通信
root_robot的博客
10-25 1213
一、管道通信的特点 1. 管道是单向的，先进先出的。 2.一个进程在管道尾部写入数据，另一个进程在管道头部读取数据。因此管道通信是半双工的。 3. 管道提供了简单的流控制机制，当进程试图读空管道时，进程将阻塞。当管道已经写满时，进程再试图向管道写入数据，进程将阻塞。 4.数据被进程读出，将从管道中删除 二、管道通信的区别 1、有名管道 2、无名管道
MFC匿名管道通信双向通信 VS2012源码
05-21
MFC匿名管道通信双向通信 VS2012源码 MFC匿名管道通信双向通信 VS2012源码 MFC匿名管道通信双向通信 VS2012源码
System.IO之使用管道在进程间通信 （System.IO.Pipes使用）
weixin_34336292的博客
08-04 662
管道的用途是在同一台机器上的进程之间通信，也可以在同一网络不同机器间通信。在.Net中可以使用匿名管道和命名管道。管道相关的类在System.IO.Pipes命名空间中。.Net中管道的本质是对windows API中管道相关函数的封装。 使用匿名管道在父子进程之间通信： 匿名管道是一种半双工通信，所谓的半双工通信是指通信的两端只有一端可写另一端可读；匿名管道只能在同一台机器上使用，不能在不同...
进程间通信 (匿名管道)
最新发布
m0_74626010的博客
04-10 754
进程间通信是一个进程把自己的数据交给另一个进程，它可以帮助我们进行数据传输、资源共享、通知事件和进程控制。进程间通信的本质是让不同的进程看到同一份资源。因此，我们要有：1、交换数据的空间。2、这个空间不能由通信双方任意一方提供。(要有一个独立的空间)
匿名管道通信
icy_Long_xiao的博客
07-07 566
匿名管道数据流向
父子进程间通信（二）—— 匿名管道通信的四种情况 及 管道的特性
challenglistic的博客
04-21 1499
父子进程通信的四种情况以及匿名管道的五个特性
进程间通信之匿名管道demo
01-13
利用匿名管道来实现进程间通信，双向。注意这种方式只能在父子进程中使用。使用方法： 两个exe，一个客户端，一个服务器，两个exe必须在同一目录下，打开NoNamedPipeParent.exe，点击创建匿名管道，此时会创建一个...
Python进程通信之匿名管道实例讲解
09-22
匿名管道是一种简单但基础的进程间通信（IPC）方式，它提供了一个单向的数据通道。在Python中，我们可以使用`os`模块提供的`pipe()`函数创建匿名管道。`os.pipe()`会返回两个文件描述符，一个用于读取（rpipe），另...
Linux通过匿名管道进行进程间通信
09-15
【Linux匿名管道进程间通信详解】 在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是实现不同进程间数据共享和协调工作的重要手段。本文将深入探讨一种常见的IPC方式——匿名管道，以及如何...
C++ MFC之进程间通信（匿名管道）
09-07
本实例利用匿名管道技术实现多进程之间的通信，实现了进程之间的发送数据和接收数据。
详解Python进程间通信之命名管道
12-25
命名管道是对传统管道的扩展，默认的管道是匿名管道，只在程序运行时存在；而命名管道是持久化的，当不需要时需要删除它。 命名管道使用文件系统，由mkfifo()方法创建。一旦创建了，两个独立的进程都可以访问它，一...
匿名管道用于进程间通信
05-10
匿名管道是操作系统提供的一种进程间通信（IPC, Inter-Process Communication）机制，尤其适用于父子进程间的简单数据交换。在Windows API中，匿名管道通常通过CreatePipe函数创建，并使用ReadFile和WriteFile函数...
进程间通信之匿名管道(pipe)
Jacksqh的博客
07-14 312
本篇博客介绍了进程间通信中常用的一种机制——匿名管道（pipe）。在现代应用程序开发中，进程间通信是一项关键任务，用于实现不同进程之间的数据传输和交互。通过本文，你将深入了解匿名管道的概念、原理和在进程间通信中的应用。
进程间通信－匿名管道
m0_61106867的博客
05-03 870
１.进程的概念 进程通信就是让两个不同的进程实现交换信息，数据。但是进程具有独立性，难以实现直接通信。但是，我们可以让进程看到同一公共空间或资源。公共空间或资源可以是文件，一段内存块等。所以实现进程间通信的方式有许多。 ２.匿名管道的特点 （１）匿名管道只能单向通信。 （２）只能用于父子进程之间。 （３）匿名管道面向字节流。 （４）自带同步机制 （５）生命周期随进程结束。 ３．匿名管道在进程中的使用 ...
进程间通信--管道
m0_62633482的博客
05-13 671
进程间通过管道通信的一些知识
进程间通信——匿名管道原理及详解（附有案例代码）
热爱数据库的小胖
07-13 2869
管道也叫无名(匿名）管道，它是是UNIX系统IPC(进程间通信)的最古老形式，所有的UNIX系统都支持这种通信机制。 统计一个目录中文件的数目命令: ls | wc -l，为了执行该命令，shell 创建了两个进程来分别执行ls 和wc；通常情况下，进程 ls 的输出直接通过 stdout 输出到控制台，但是为了两个进程能够进行通信，系统会建立一个管道，然后把进程 ls 发的内容输出到管道，进程 wc 从管道中读取进程 ls 输出的内容，从而实现进程间的通信。 A.管道其实是一个在内核内存中维护
进程间通信管道篇（匿名管道，命名管道）
Odfogy的博客
10-25 434
目录一、匿名管道1.管道的概念2、管道与进程通信的关系3、建立管道4、单个进程使用管道读写5、实现两个进程间的匿名管道通信二、命名管道1.引入库2.读入数据总结 一、匿名管道 1.管道的概念 管道就是内存中由操作系统维护的一块缓冲区。 2、管道与进程通信的关系 进程之间通信时通过管道作为中转站，一个输入一个读取，减少接口的复杂度。 3、建立管道 int pipe(int pipefd[2]); 参数:整型数组，数组中保存是是文件描述符，分别是可读和可写。数组内的两个文件描述符都是是直接由pipe函数进行
进程间通信（管道、消息队列、共享内存、信号量）.docx
07-22
匿名管道没有名字，仅用于具有亲缘关系的进程间通信，而命名管道则可以用于不具有亲缘关系的进程之间通信。创建匿名管道可以使用操作系统提供的pipe函数。 2.消息队列 消息队列是一种在进程之间传输消息的方式，它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值