进程间通信---管道

已于 2023-04-23 18:33:16 修改
阅读量643 收藏 8
点赞数 13
文章标签： c 进程间通信 Linux
于 2023-04-23 18:29:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61433144/article/details/130327594
版权

进程间通信

概念

进程间通信就是在不同进程之间传播或交换信息数据, 简称IPC（Interprocess communication）.

意义
  • 数据传输, 资源共享
  • 事件通知, 进程控制
本质

让不同的进程看到同一份资源

管道

匿名管道

原理:

匿名管道仅限于本地父子进程之间的通信, 本质就是让两个父子进程先看到同一份被打开的文件资源, 然后父子进程就可以对该文件进行写入或是读取操作, 进而实现进程间通信.

pipe函数:

  • int pipe(int pipefd[2]); // #include <unistd.h>
  • pipefd: 输出型参数, 数组pipefd用于返回两个指向管道读端和写端的文件描述符. pipefd[0]是管道读端的文件描述符, pipefd[1]是管道写端的文件描述符.
  • return int: pipe函数调用成功时返回0, 调用失败时返回-1.
  • 注意: 管道的信道是半双工的.

使用(父进程读, 子进程写为例):

  1. 父进程通过调用pipe函数创建管道
  2. 父进程创建子进程
  3. 父进程关闭写端，子进程关闭读端
// 父进程读子进程写---父进程关闭写端,子进程关闭读端 
static void test_pipe1()
{
    // 1.父进程先调用pipe函数,创建匿名管道获取读写端的文件描述符
    int pipefd[2];
    memset(pipefd,0,sizeof(pipefd));

    int ret=pipe(pipefd);
    if(ret!=0)
    {
        perror("pipe");
        exit(1);
    }

    // 2.父进程调用fork创建子进程, 在进程创建中子进程会继承父进程的struct file, 
    // 所以父子进程的pipefd中文件描述符会标定同一个匿名管道
    pid_t id=fork();
    if(id<0)
    {
        perror("fork");
        exit(2);
    }
    
    // 3.因为管道通信是半双工的, 所以需要根据需求关闭父子进程各一个fd

    if(0==id) 
    {
        // child code
        close(pipefd[0]);
        
        int n=10;
        while(n--)
        {
            char buffer[1024];
            sprintf(buffer,"hello father, I am child: %d",n);
            write(pipefd[1],buffer,strlen(buffer));
                
            sleep(1);
        }

        close(pipefd[1]);
        exit(0);
    }

    // father code
    close(pipefd[1]);
    
    while(true)
    {
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));

        ssize_t n=read(pipefd[0],buffer,sizeof(buffer)-1);
        if(n>0)
        {
            buffer[n]='\0';

            printf("chlid# %s\n",buffer);
        }
        else if(0==n)
        {
            printf("child exit");
            break;
        }
        else 
        {
            perror("read");
            exit(3);
        }
    }

    close(pipefd[0]);
    exit(0);
}

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

    return 0;
}

运行结果:

image-20230420192048772

四种特殊情况:

  1. 写端进程不写, 读端进程一直读, 那么此时会因为管道里面没有数据可读, 对应的读端进程会被挂起, 直到管道里面有数据后, 读端进程才会被唤醒.

  2. 读端进程不读, 写端进程一直写, 那么当管道被写满后, 对应的写端进程会被挂起, 直到管道当中的数据被读端进程读取后, 写端进程才会被唤醒.

  3. 写端进程将数据写完后将写端关闭, 那么读端进程将管道当中的数据读完后, 就会继续执行该进程之后的代码逻辑, 而不会被挂起.

  4. 读端进程将读端关闭, 而写端进程还在一直向管道写入数据, 那么操作系统会通过发送SIGPIPE信号给写端进程从而将写端进程杀掉.

验证第4种情况, 当写端进程一直往匿名管道写时, 读端进程把匿名管道对应的读取文件描述符关闭, 写端进程会收到什么信号(父进程写, 子进程读为例):

void sigpipe_handler(int signum)
{
    printf("收到信号: %d\n",signum);
    exit(4);
}

// 父进程写子进程读---父进程关闭读端,子进程关闭写端
static void test_pipe2()
{
    // 1.pipe
    int pipefd[2];
    int ret=pipe(pipefd);
    if(ret<0)
    {
        perror("pipe");
        exit(1);
    }

    // 2.fork
    pid_t id=fork();
    if(id<0)
    {
        perror("fork");
        exit(2);
    }

    if(0==id)
    {
        // child code
        close(pipefd[1]); // 子进程关闭写端

        int n=3;
        while(n--)
        {
            char buffer[1024];

            ssize_t n=read(pipefd[0],buffer,sizeof(buffer)-1);
            if(n>0)
            {
                buffer[n]='\0';
                printf("father# %s\n",buffer);

                // sleep(1);
            }
            else if(0==n) 
            {
                printf("father close\n");
                exit(0);
            }
            else
            {
                perror("read");
                exit(3);
            }
        }

        close(pipefd[0]);
        exit(0);
    }

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

    // 父进程对SIGPIPE信号进行捕获
    signal(SIGPIPE,sigpipe_handler);

    // 父进程一直往匿名管道中写入数据
    int count=0;
    while(true)
    {
        char buffer[1024];
        sprintf(buffer,"I am father, pid: %d, count %d\n",getpid(),count++);

        ssize_t n=write(pipefd[1],buffer,strlen(buffer));
        if(n>0)
        {
            // printf("write n>0: n: %d\n",n);
            usleep(5000); // 父进程写慢点
        }   
        else if(0==n)
        {
            printf("write 0==n: n: %d\n",n);
            break;
        }
        else
        {
            perror("write");
            exit(5);
        }
    }

    close(1);
    exit(0);
}

运行结果:

image-20230420201150260

测试管道的大小:

// 测试管道的大小,父进程一直不读,子进程一直写
static void test_pipe_size()
{
    // 1.pipe
    int pipefd[2];
    int ret = pipe(pipefd);
    if (ret < 0)
    {
        perror("pipe");
        exit(1);
    }

    // 2.fork
    pid_t id = fork();
    if (id < 0)
    {
        perror("fork");
        exit(2);
    }

    if (0 == id)
    {
        // child code
        close(pipefd[0]); // 子进程关闭写端
        // 子进程一直往匿名管道中写
        
        int count = 0; // 记录写入了多少个字节数
        while (true)
        {
            char one_byte = '$';
            ssize_t n = write(pipefd[1], &one_byte, 1);

            if (n > 0)
            {
                printf("count: %d bytes\n", ++count);
            }
        }

        close(pipefd[1]);
        exit(0);
    }

    // father code
    close(pipefd[1]); // 父进程关闭读端
    // 父进程一直不从匿名管道中读
    for(;;){}

    close(pipefd[0]);
    exit(0);
}

结论：我当前Linux版本（Linux VM-12-12-centos 3.10.0-1160.62.1.el7.x86_64 #1 SMP Tue Apr 5 16:57:59 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux）中管道的最大容量是65536字节. 当管道写满时, 写端进程继续写则会进入阻塞状态.

image-20230420203123618

命名管道

原理:

想要实现本地任意两个进程之间的通信, 可以通过命名管道来实现. 命名管道是一种特殊类型的文件(管道文件), 两个进程通过命名管道的文件路径打开同一个管道文件, 此时这两个进程也就看到了同一份资源，进而就可以进行进程间通信了。

mkfifo函数:

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

pathname: 根据传入pathname所指定的目录下创建命名管道文件, 默认在当前进程的工作目录下创建.

  1. /home/yx/code/ipc_fifo/fifofile: 表示在/home/yx/code/ipc_fifo目录下创建fifofile文件
  2. fifofile: 表示在默认目录下创建fifofile文件

mode: 表示创建命名管道文件的默认权限, 受usmask权限掩码影响, 实际权限=mode&(~umask);

return int: 创建成功返回0, 创建失败返回-1.

使用:

comm.h

#ifndef __COMM_H__
#define __COMM_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

const char * FIFOFILEPATH="fifofile";
const int DEFAULTMODE=0666;
const int BUFFERSIZE=1024;

#endif

fifoServer.c

#include "comm.h"

static void server()
{
    // 1.调用mkfifo创建管道文件
    int ret=mkfifo(FIFOFILEPATH,DEFAULTMODE);
    if(ret<0) // 成功返回0,失败返回-1
    {
        perror("mkfifo");
        exit(1);
    }

    // 2.调用open以读的方式打开管道文件
    int fifo_fd=open(FIFOFILEPATH,O_RDONLY);
    if(fifo_fd<0)
    {
        perror("open");
        exit(2);
    }

    // 3.调用read从管道文件中读取数据
    char buffer[BUFFERSIZE];
    while(true)
    {
        ssize_t n=read(fifo_fd,buffer,sizeof(buffer)-1);
        if(n>0)
        {
            buffer[n]='\0';
            printf("%s\n",buffer);
        } 
        else if(n==0)
        {
            printf("client exit\n");
            break;
        }
        else
        {
            perror("read");
            close(fifo_fd); // 关闭fifo_fd文件描述符
            unlink(FIFOFILEPATH); // 删除管道文件
            exit(4);
        }
    }

    close(fifo_fd);
    unlink(FIFOFILEPATH);
    exit(0);
}

int main()
{
    server();

    return 0;
}

fifoClient.c

#include "comm.h"

static void client()
{
    // 1.调用open以写的方式打开管道文件
    int fifo_fd=open(FIFOFILEPATH,O_WRONLY);
    if(fifo_fd<0)
    {
        perror("open");
        exit(1);
    }

    // 2.调用write往管道文件中写入数据
    char buffer[BUFFERSIZE];
    while(true)
    {
        // 从0号文件描述符读取数据z
        printf("client# ");
        fflush(stdout);

        ssize_t n=read(0,buffer,sizeof(buffer)-1);
        buffer[n]='\0';

        // 将读取到的数据往管道文件中写入
        n=write(fifo_fd,buffer,strlen(buffer));
        if(n>0)
        {
            printf("write success n: %d\n",n);
        }
        else if(n==0)
        {
            // 读端关闭
            exit(2);
        }
        else
        {
            // 写入错误
            exit(3);
        }
    }

}

int main()
{
    client();
    return 0;
}

测试:

服务端先启动, 紧接着启动客户端. 客户端发送hello server, 可以看到服务端可以收到, 也即通过命名管道完成进程间通信. 客户端(写端)退出, 服务端(读端)也退出.
image-20230423180048142

羊羊羊三斤
关注
  • 13
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
进程间通信 - 管道
酒红的专栏
04-16 1036
介绍进程间的通信方式之一——管道，其原理及适用点，以及相应的C代码实现示例。
进程间通信之---管道
weixin_45897952的博客
03-19 1360
1.为啥需要进程间通信呢? 1.1原因： 每一个进程的数据都足存储在物理内存当中，进程通过各自的进程虚拟地址空间进行访问，访问的时候，通过各自的页表的映射关系，访问到物理内存。从进程的角度看，每个进程都认为首己拥有4G的空间，至 于物力内存当中属于如何存储，页 表如何映射，进程是不清楚。 这 也造就了进程的独立行。 1.2进程独立性: 好处:让每- -个进程在运行的时候，都是 独立进行运行的，数据不会窜。 坏处:如果两个进程之间需要数据交换，那么由于进程独立行..
Linux进程间通讯 -- 管道
爱出名的狗腿子
01-07 934
在 Linux 中每个进程都具备独立的进程地址空间，对每个进程的独立地址空间进行划分，在0G - 3G部分被划分为用户空间，而3G - 4G部分被划分为内核地址空间。在进行地址映射的时候，每个进程的用户空间在实际物理空间上将被映射到多个地址空间，而多个进程的内核空间将会被被映射到同一块区域，因此多个进程之间具备相同的内核地址空间，通过此共同的内核地址空间实现线程间数据交互即为进程间通讯，也即IPC。当管道中数据被写满时，再次往管道内写入数据会进入阻塞等待状态，直至有数据从管道的读端被读走。
【Linux】17. 进程间通信 --- 管道
最新发布
weixin_60915103的博客
05-07 845
该篇文章介绍了进程间通信中的管道通信，包含：进程间通信的目的/发展 认识管道，匿名管道，管道特点，匿名管道进程池，命名管道通信等内容。快来看看吧！
【Linux】进程间通信--管道（匿名管道和命名管道）
呋喃吖的博客
04-23 3798
文章目录前言进程间通信的目的管道匿名管道管道特点在文件描述符角度理解管道 前言 进程间的通信，其实就是两个进程需要进行交流，从另一个角度上想：进程本身就是程序员给开辟的，所以进程间通信也就是程序员的通信； 我们需要理解的是：进程通信是存在协同的场景的（也就是有顺序的场景）； 比如：cat test.c | wc -l 这条命令：就是把 cat进程的结果交给wc进程去执行，这就是先后顺序； 但是我们知道进程之间是独立的，那么也就是说：不同的进程是看不到对方的资源的； 这么来说既然独立，进程是如何通信的呢？
【Linux】进程间通信 -- 命名管道
m0_72563041的博客
04-18 998
【Linux】命名管道
Linux进程间通信--命名管道
码城的博客
08-05 2772
Linux进程间通信机制--命名管道
进程间通信－匿名管道
m0_61106867的博客
05-03 870
１.进程的概念 进程通信就是让两个不同的进程实现交换信息，数据。但是进程具有独立性，难以实现直接通信。但是，我们可以让进程看到同一公共空间或资源。公共空间或资源可以是文件，一段内存块等。所以实现进程间通信的方式有许多。 ２.匿名管道的特点 （１）匿名管道只能单向通信。 （２）只能用于父子进程之间。 （３）匿名管道面向字节流。 （４）自带同步机制 （５）生命周期随进程结束。 ３．匿名管道在进程中的使用 ...
进程间通信---匿名管道
m0_61567378的博客
04-25 1447
导语 我们需要不同进程之间相互协同，进程之间的协同本质上是程序员之间的协同，有可能为要从数据库中拿数据，你要从数据库中将数据格式化，写成特定的格式，我要根据特定的格式做数据统计，这一件事情，有一个无法实现这个事情就无法完成, 我们可以将这一件事情拆分成3个事情：一个进程专门从数据库中拿数据，一个进程专门做数据格式化，还有一个进程专门做数据统计 第一个处理完之后交给第二个，第二个处理完之后交给第三个 这样我们就可以实现业务上的通信，这样就增加了代码的可维护性 ...
Linux 进程通信 -- 管道
Once_fish_的博客
04-17 1643
1、管道简介 管道是Linux提供的进程间通信机制之一，允许通信进程之间通过文件读写的方式单向传递数据。内核实现的文件系统pipefs，会在内核为每个管道文件分配一个的环形缓存区，以支持读/写操作。进程可以使用两种类型的管道进行通信： 匿名管道：只支持在父子进程、兄弟进程之间通信。一般使用方式为，父进程调用pipe()创建匿名管道，fork()的子进程默认继承父进程打开的管道 命名管道：支持任意的进程通过管道通信。进程通信前，需要先创建fifo类型特殊的文件，然后读写进程分别打开该文件进行读写 2、
进程间通信-管道
04-29
总结起来，命名管道是进程间通信的一种有效手段，尤其适用于同一系统内的进程通信。通过`mkfifo()`、`open()`、`write()`和`read()`等系统调用，我们可以构建起可靠的通信链路。`PipeC.cpp`和`PipeS.cpp`的代码示例...
操作系统实验五-进程间通信-管道通信
12-06
操作系统实验五 进程间通信——管道通信 无名管道 有名管道 write()和read() pipe() 函数int pipe(int fd[2])创建一个管道 lockf()函数使用管道通信时，可关闭某些不需要的读或写描述符wait()、waitpid()，sys/wait....
Linux的进程间通信-管道.doc
04-30
Linux的进程间通信-管道.doc
linux系统编程--进程间通信--管道
08-21
Linux系统编程--进程间通信--管道 在Linux系统中，进程间通信是指不同的进程之间交换数据和信息的方式。由于进程之间的地址空间相对独立，不能像线程之间通过全局变量通信，因此需要其他机制来实现进程间通信。 ...
进程间通信-邮槽
04-29
进程间通信（IPC，Inter-Process Communication）是操作系统中一种重要的技术，允许不同的进程之间共享数据和信息。在Windows操作系统中，提供了多种实现IPC的方法，其中包括邮槽（Mailslot）。邮槽是一种简单且高效...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8824
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3271
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3710
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1541
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
linux系统-进程间通信
07-27
\[1\]\[2\]常见的进程间通信方式包括共享内存、管道、消息队列和信号量等。\[2\]在实现进程间通信时，需要关闭对应的文件描述符，子进程关闭读端，父进程关闭写端，然后通过读写操作进行数据的传输。\[3\]通过这种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值