进程间通信之管道通信

最新推荐文章于 2024-03-19 20:21:29 发布
最新推荐文章于 2024-03-19 20:21:29 发布
阅读量570 收藏
点赞数 1
分类专栏： 苏嵌学习 文章标签： 数据 通信 函数 command
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/believe_s/article/details/77294586
版权

两个程序之间传递数据的一种简单方法是使用popen和pclose。

#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
    popen函数允许一个程序将另一个程序作为新进程来启动，并可以传递数据给它或者通过它接收数据。command字符串是要运行的程序名和相应的参数。type必须是"r"或"w"。
    如果type是"r"，被调程序的输出就可以被调用程序使用，调用程序利用popen函数返回的FILE *文件流指针，可以读取被调程序的输出；如果type是"w"，调用程序就可以向被调程序发送数据，而被调程序可以在自己的标准输入上读取这些数据。
    pclose函数只在popen启动的进程结束后才返回。如果调用pclose时它仍在运行，pclose将等待该进程的结束。

#include <stdio.h>

#define SIZE 1024*100

int main()
{
    FILE *fp = popen("ps -ef", "r");
    if (fp == NULL)
    {
        perror ("popen");
        return -1;
    }

    char buf[SIZE] = {0};

    int ret = fread(buf, sizeof(char), SIZE-1, fp);

    // printf ("读到的数据:\n %s\n", buf);


    FILE *fp2 = popen("grep a.out", "w");
    if (fp2 == NULL)
    {
        perror ("popen");
        return -1;
    }

    fwrite (buf, sizeof(char), ret, fp2);
    printf ("写入完成\n");

    pclose (fp);
    pclose (fp2);

    return 0;
}

管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道尾部写入数据，另一个进程（读进程）从管道的头部读出数据。管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。
无名管道由pipe( )函数创建：

int pipe(int filedis[2]);

当一个管道建立时，它会创建两个文件描述符：filedis[0]fi用于读管道，ledis[1]
用于写管道。
这里写图片描述
管道用于不同进程间通信。通常先创建一个管道，在通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道描述符。必须在系统调用fork()前调用pipe()，否则子进程将不会继承文件描述符。

1、单个进程中的管道

#include <stdio.h>
#include <unistd.h>

#define SIZE 1024*100

int main()
{
    int fd[2];

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

    ret = write (fd[1], "hello", 5);


    printf ("写入 %d 个字节\n", ret);
    char ch;
    while (1)
    {
        // 如果管道里面没有数据可读，read会阻塞
        ret = read (fd[0], &ch, 1);
        if (ret == -1)
        {
            perror ("read");
            break;
        }

        printf ("读到 %d 字节： %c\n", ret, ch);
    }
    close (fd[0]);
    close (fd[1]);

    return 0;
}

2、父子进程通过管道进行通信

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>

#define SIZE 1024

// 子进程通过管道从父进程接收数据
void child_do(int *fd)
{
    // 将管道的写端关闭
    close (fd[1]);

    char buf [SIZE];

    while (1)
    {
        // 从父进程读取数据
        int ret = read (fd[0], buf, SIZE-1);
        if (ret == -1)
        {
            perror ("read");
            break;
        }
        buf[ret] = '\0';
        printf ("子进程读到 %d 字节数据： %s\n", ret, buf);
    }

    // 关闭读端
    close (fd[0]);
}

// 父进程通过管道向子进程发送数据
void father_do(int *fd)
{
    // 将管道读端关闭
    close (fd[0]);

    char buf[SIZE];

    while (1)
    {
        fgets (buf, SIZE, stdin);

        // 向子进程发送数据
        int ret = write (fd[1], buf, strlen(buf));
        printf ("父进程发送了 %d 字节数据\n", ret);
    }

    // 关闭写端
    close (fd[1]);
}

int main()
{
    int fd[2];

    // 创建管道
    int ret = pipe(fd);
    if (ret == -1)
    {
        perror ("pipe");
        return -1;
    }

    // 创建子进程
    pid_t pid = fork();

    switch (pid)
    {
        case -1:
            perror ("fork");
            break;
        case 0:   // 子进程
            child_do(fd);
            break;
        default:
            father_do(fd);
            break;
    }

    return 0;
}

3、父子进程通过管道实现文件复制

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

#define SIZE 1024

// 子进程通过管道从父进程接收数据
void child_do(int *fd)
{
    // 将管道的写端关闭
    close (fd[1]);

    int fd_write = open ("2.mmap", O_WRONLY|O_CREAT, 0777);
    if (fd_write == -1)
    {
        perror ("open");
        return;
    }
    int ret;
    char buf [SIZE];

    // read 从管道读数据，如果管道没有数据可读，read 会阻塞
    // 如果 管道的写端 被关闭， read 返回 0
    while (ret = read (fd[0], buf, SIZE))
    {
        if (ret == -1)
        {
            perror ("read");
            break;
        }

        // 把从父进程接收的数据写入到新文件中
        write (fd_write, buf, ret);
    }

    printf ("文件复制完成\n");
    // 关闭读端
    close (fd[0]);
    close (fd_write);
}

// 父进程通过管道向子进程发送数据
void father_do(int *fd)
{
    // 将管道读端关闭
    close (fd[0]);

    int fd_read = open ("1.mmap", O_RDONLY);
    if (fd_read == -1)
    {
        perror ("open");
        return;
    }
    int ret;
    char buf[SIZE];
    while (ret = read (fd_read, buf, SIZE))
    {
        if (ret == -1)
        {
            perror ("read");
            break;
        }

        // 把读到的内容发送给子进程
        write (fd[1], buf, ret);
    }

    // 关闭写端
    close (fd[1]);
    close (fd_read);
}

int main()
{
    int fd[2];

    // 创建管道
    int ret = pipe(fd);
    if (ret == -1)
    {
        perror ("pipe");
        return -1;
    }

    // 创建子进程
    pid_t pid = fork();

    switch (pid)
    {
        case -1:
            perror ("fork");
            break;
        case 0:   // 子进程
            child_do(fd);
            break;
        default:
            father_do(fd);
            break;
    }

    return 0;
}

4、管道读端关闭，写端继续写数据

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>

#define SIZE 1024

// 子进程通过管道从父进程接收数据
void child_do(int *fd)
{
    close (fd[1]);
    close (fd[0]);
}

void father_do(int *fd)
{
    // 将管道读端关闭
    close (fd[0]);

    printf ("等待子进程关闭读端\n");
    sleep(2);

    // 所有读端都关闭了，写端继续往管道写入数据
    // 如果管道所有的读端都被关闭，继续写数据系统默认的操作是使程序退出
    write (fd[1], "hello", 5);


    printf ("11111111111111111111111111111111\n");
    // 关闭写端
    close (fd[1]);
}

int main()
{
    int fd[2];

    // 创建管道
    int ret = pipe(fd);
    if (ret == -1)
    {
        perror ("pipe");
        return -1;
    }

    // 创建子进程
    pid_t pid = fork();

    switch (pid)
    {
        case -1:
            perror ("fork");
            break;
        case 0:   // 子进程
            child_do(fd);
            break;
        default:
            father_do(fd);
            break;
    }

    return 0;
}

以上是无名管道常用的一些操作。

命名管道（FIFO）和无名管道基本相同，但也有不同点：无名管道只能由父子进程使用；但是通过命名管道，不相关的进程也能交换数据。

命名管道具有很好的使用灵活性，表现在:

1) 既可用于本地，又可用于网络。

2) 可以通过它的名称而被引用。

3) 支持多客户机连接。

4) 支持双向通信。

5) 支持异步重叠I/O操作。

1、创建命名管道

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

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

pathname: FIFO文件名
mode:属性（同文件操作）

一旦创建了一个FIFO,就可用open打开它，一般的文件访问函数（close、read、write等）都可用于FIFO。

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

int main()
{
    int ret = mkfifo("/home/mkfifo", 0777);
    if (ret == -1)
    {
        perror ("mkfifo");
        return -1;
    }

    return 0;
}

2、命名管道的传输
当打开FIFO时，非阻塞标识（O_NONBLOCK）将对以后的读写产生影响：
1、没有使用O_NONBLOCK:访问要求无法满足时进程将阻塞。如果试图读取空的FIFO，将导致进程阻塞。
2、使用O_NONBLOCK:访问要求无法满足时不阻塞，立刻出错返回。errno是ENXIO。

写入：

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

#define SIZE 1024

int main()
{
    int fd = open("/home/mkfifo", O_WRONLY);
    if (fd== -1)
    {
        perror ("mkfifo");
        return -1;
    }

    char buf[SIZE];
    while (1)
    {
        fgets (buf, SIZE, stdin);

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

    return 0;
}

读取：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#define SIZE 1024

int main()
{
    int fd = open("/home/mkfifo", O_RDWR);
    if (fd == -1)
    {
        perror ("mkfifo");
        return -1;
    }

    char buf[SIZE];
    while (1)
    {
        int ret = read (fd, buf, SIZE);
        buf[ret] = '\0';

        printf ("读到 %d 字节: %s\n", ret, buf);
    }

    return 0;
}

管道作为进程间通信的4种方式之一，他并不会保存数据，区别与共享内存。

believe_s
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
定义一个Father和Child类，并进行测试。
01-05
定义一个Father和Child类，并进行测试。 要求如下： 1）Father类为外部类，类中定义一个私有的String类型的属性name，name的值为“zhangjun”。 2）Child类为Father类的内部类，其中定义一个introFather()方法，方法中调用Father类的name属性。 3）定义一个测试类Test，在Test类的main()方法中，创建Child对象，并调用introFather ()方法。
jQuery+css last-child实现选择最后一个子元素操作示例
10-17
主要介绍了jQuery+css last-child实现选择最后一个子元素操作,结合实例形式分析了jQuery结合css进行页面元素选择与样式修改相关操作技巧,需要的朋友可以参考下
进程间通信 之 管道
最新发布
纪宁的博客
03-19 686
管道是Unix中最古老的进程间通信的形式。它是一种基于文件的通信形式，我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。管道文件是一种纯内存文件，不需要刷新到磁盘。管道只允许单向通信，如果要双向通信的话，需要建立两个管道，“互相读写”！
基于react组件之间的参数传递(详解)
12-09
1、父组件向子组件传递参数 class Child extends Component { 　　　 componentDidMount(){ 　　　 　　let name = this.props.default; 　　　　　 console,log(name); 　　　 } 　　　 render(){ 　　　　　 const { default} = this.props; 　　　 　　return ( 　　　　　　　　<Input /> 　　　　　　) } } import React, { Component } from 'react'; import Child from
父子进程拷贝文件
09-01
linux C语言，编程实现父子进程同时拷贝文件，各复制一半
进程间通信和同步
知足且坚定，温柔且上进
01-28 735
目录半双工管道基本概念pipe()函数介绍pipe()函数的例子管道阻塞和管道操作的原子性管道操作原子性的代码命名管道创建FIFOFIFO操作消息队列消息缓冲区结构结构msgid_ds结构ipc_perm内核中的消息队列关系键值构建ftok()函数获得消息msgget()函数发送消息msgsnd()函数接收消息msgrcv()函数消息控制msgctl()函数消息队列的一个例子显示消息属性的函数msg_show_attr()信号量信号量数据结构新建信号量函数semget()信号量操作函数semop()控制信号
进程的管道通信编制一段程序，实现进程的管道通信，使用系统调用pipe（）建立一个管道文件；两个子进程P1和P2
03-13
进程的管道通信 编制一段程序，实现进程的管道通信，使用系统调用pipe（）建立一个管道文件；两个子进程P1和P2 分别向管道各写一句话： Child1 is sending a message！ Child2 is sending a message！ 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的 消息，然后再接收子进程P2发来的消息。
进程通信－－进程管道
sever2012的专栏
12-26 1744
进程间通信的几种常用方式： 管道、命名管道、信号、信号量、共享内存、消息队列、套接字。 管道( pipe )：一种半双工的通信方式，数据只能单向流动且只能在具有共同祖先的进程间使用。 命名管道 (name pipe)：也是一种半双工的通信方式，但他允许不相关进程间的通信。 信号( sinal )：一个进程通过信号通知其他进程某事件已经发生，其他进程的反应如何及何时反应他都不管。 信号
进程间通信之管道
weixin_33736048的博客
07-19 116
进程间通信之管道进程间通信：每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核(操作系统),在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信。本质：让不同的进程可以访问同一块系统资源。实现方式：一、最基本的进程间通信机制--管道（由pi...
进程管道的通信
qq_39884728的博客
08-02 204
三 管道 管道分为：有名管道，无名管道 无名管道的创建使用pipe(2)： #include <unistd.h> int pipe(int pipefd[2]); 功能：创建管道 参数： pipefd[2]:管道的两个文件描述符。 pipefd[0]:读端 pipefd[1]:写端 返回值： 0 成功 -1 错误 errno被设置 举例验证代码使用pipe.c 1.父进程创建管道 2. fork(2创建子进程 3.父进程关闭写端，子进程关闭读端 4....
进程管道通信
oSanWenYu的专栏
08-07 681
一、管道通信 1、pipe
进程通信——管道通信
11-28
进程间通信，命名管道通信，MFC实现，从原项目拷贝出来
通过在VS中编程实现父子进程的管道通信.zip
07-27
通过在VS中编程，实现父子进程的管道通信，要求父进程从窗口中输入数字，输入的数字通过管道传输给子进程，子进程将输入的字符串进行相加求和，同时打开readme.txt文件计算完成后读取文档中的一行，最后以 和_文档某行字符串的形式进行管道通信返回给父进程。
进程控制 进程的管道通信
07-03
使用系统调用pipe（）建立一个管道，两个子进程分别向管道写信息，父进程则从管道读出来自子进程的信息，显示在屏幕上，记录屏幕的显示结果，分析原因。 任务 编制一段程序，实现进程的管道通信。使用系统调用pipe()建立一条管道线。两个子进程p1和p2分别向管道各写一句话： Child 1 is sending message! Child 2 is sending message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
C# 使用管道Pipe在进程间通信
03-25
进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在Win9X下只支持有名管道客户。 1、进程间通信 2、管道Pipe通信
进程间通信之匿名管道demo
01-13
利用匿名管道来实现进程间通信，双向。注意这种方式只能在父子进程中使用。使用方法： 两个exe，一个客户端，一个服务器，两个exe必须在同一目录下，打开NoNamedPipeParent.exe，点击创建匿名管道，此时会创建一个...
Python中的进程间通信
12-20
文章目录Python中的进程间通信1 进程间通信1.1 概念1.2进程间通信方法各种进程间通信1. 基于信号量（Semaphore）的IPC2 基于信号（Signal）的IPC3.基于管道（Pipe）的IPC4. 基于有名管道（fifo）的IPC5.基于消息队列...
详解Python进程间通信之命名管道
12-25
通常启动进程创建一个管道，然后这个进程创建一个或者多个进程子进程接受管道信息，由于管道是单向通信，所以经常需要创建两个管道来实现双向通信。 命名管道是对传统管道的扩展，默认的管道是匿名管道，只在程序...
mfc 进程间通信 管道 双向
09-28
在MFC中，使用管道进行进程间通信可以分为两个步骤：创建管道和使用管道进行通信。 首先，需要创建一个管道。可以使用CreatePipe函数来创建匿名管道，它接受两个参数，第一个参数是用于接收管道句柄的指针，第二个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值