系统编程二(管道)

最新推荐文章于 2022-03-27 03:45:00 发布
最新推荐文章于 2022-03-27 03:45:00 发布
阅读量188 收藏
点赞数
分类专栏： 系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41827817/article/details/105027568
版权

1.简介

查看管道命令：

man 7 pipe

前一个的输出作为，后一个的输入，用做进程之间的通讯工具。

分类：
匿名管道
FIFO管道/命名管道

2.匿名管道

2.1 单工管道(四个操作)

程序进程与Shell命令行进程单项通信。
一.打开管道：

FILE* popen (const char *command, const char *open_mode)

参数说明：

参数含义
command命令行字符串
open_mode"r"只读"w"只写

返回值说明：

返回值含义
NULL文件描述符
非NULL打开失败

二.读取：

size_t fread ( void *buffer, size_t size, size_t count, FILE *stream)

参数说明：

参数含义
buffer用于接收数据的内存地址
size读取每个数据项的字节数
count数据项个数
stream输入流

返回值说明：

返回值含义
>count出错
正数真实读取的数据项个数

三.写入:

size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream)

参数说明：

参数含义
buffer写入数据的内存地址
size写入数据项的字节数
count写入数据项的个数
stream目标文件指针

返回值说明：

返回值含义
>count出错
正数真实写入的数据项个数

四.关闭管道:

int pclose(FILE *stream);

参数说明：

参数含义
stream文件描述符

返回值说明：

返回值含义
-1失败
0成功

示例一（写）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
    FILE* fd = popen("wc","w");
    //FILE* fd = popen("ls -l","r");
    //char str[] = "123 456";       
    char str[] = "123 456\n";       
    size_t n = fwrite(str,sizeof(char),sizeof(str),fd);
    if(n > sizeof(str)){
        fprintf(stderr,"FILE:%d,LINE:%d-fwrite error",__FILE__,__LINE__);
        exit(EXIT_FAILURE);
    }
    pclose(fd);
}

示例二（读）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
    FILE* fd = popen("ps -ef","r");
    //FILE* fd = popen("ls -l","r");
         
    char buf[BUFSIZ];
    size_t count = 0;
    printf("read data:\n");
    do{
        memset(buf,'\0',BUFSIZ);
        size_t n = fread(buf,sizeof(char),BUFSIZ-1,fd);
        if( n > BUFSIZ - 1 ){
            perror("fread error");
            exit(EXIT_FAILURE);
        }
        count += n;
        printf("\n%d:\n%s",n,buf);
    }while(!feof(fd));
    printf("total size:%ld\n",count);
    pclose(fd);
}

在这里插入图片描述

半双工通道

一.创建管道：

int pipe(int filedes[2])

参数说明：

参数含义
filedes[0]读
filedes[1]写

返回值说明：

参数含义
-1失败
0成功

二.读取：

ssize_t write(int fd, const void *buf, size_t nbyte)

参数说明：

参数含义
fd文件描述符
buf写入数据的内存单元
nbyte写入文件指定的字节数

返回值说明：

参数含义
-1出错
正数写入的字节数

三.写入

ssize_t read(int fd, void *buf, size_t count)

参数说明：

参数含义
fd文件描述符
buf读取数据的内存单元

返回值说明：

参数含义
-1出错
0无数据
正数读取的字节数

四.控制

int fcntl(int fd, int cmd, long arg)

如果管道是空的，read()默认是阻塞
参数说明：

参数含义
fd文件描述符
cmdF_GETFL:获取文件描述符状态;F_SETFL:设置文件描述符状态;
argO_NONBLOCK:非阻塞;O_BLOCK:阻塞

五.关闭管道

close(filedes)

示例
单进程读写管道：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
    int fd[2];
    pipe(fd);
    char in[] = "Hello pipe";
    write(fd[1],in,sizeof(in));
    printf("write:%s\n",in);
 
    char out[sizeof(in)]={0};
    ssize_t n = read(fd[0],out,sizeof(out));
    if(-1 == n){
        perror("read error");
        return -1;
    }
    printf("read:%s\n",out);
 
    close(fd[0]);
    close(fd[1]);
}

两进程读写:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
    int fd[2];
    pipe(fd);
    if(!fork()){// child
        char in[] = "Hello pipe";
        write(fd[1],in,sizeof(in));
        printf("child %d write:%s\n",getpid(),in);
    }else{// parent
        char out[BUFSIZ]={0};
        ssize_t n = read(fd[0],out,sizeof(out));
        if(-1 == n){
            perror("read error");
            return -1;
        }
        printf("parent %d read:%s\n",getpid(),out);
    }
    close(fd[0]);
    close(fd[1]);
}

两进程先读后写:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
    int fd[2];
    pipe(fd);
    if(!fork()){// child
        char in[] = "Hello pipe";
        sleep(3);
        write(fd[1],in,sizeof(in));
        printf("child %d write:%s\n",getpid(),in);
    }else{// parent
        char out[BUFSIZ]={0};
        ssize_t n = read(fd[0],out,sizeof(out));
        if(-1 == n){
            perror("read error");
            return -1;
        }
        printf("parent %d read:%s\n",getpid(),out);
    }
    close(fd[0]);
    close(fd[1]);
}

两进程先读后写(非阻塞):

include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
 
int main(){
    int fd[2];
    pipe(fd);
    if(!fork()){// child
        char in[] = "Hello pipe";
        sleep(3);
        write(fd[1],in,sizeof(in));
        printf("child %d write:%s\n",getpid(),in);
    }else{// parent
        fcntl(fd[0],F_SETFL,O_NONBLOCK);
        char out[BUFSIZ]={0};
        ssize_t n = read(fd[0],out,sizeof(out));
        if(-1 == n){
            perror("read error");
            return -1;
        }
        printf("parent %d read:%s\n",getpid(),out);
    }
    close(fd[0]);
    close(fd[1]);
}

更加规范的写法(关闭不需要的管道)：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
 
int main(){
    int fd[2];
    pipe(fd);
    if(!fork()){// child
        close(fd[0]);
        char in[] = "Hello pipe";
        sleep(3);
        write(fd[1],in,sizeof(in));
        printf("child %d write:%s\n",getpid(),in);
        close(fd[1]);
    }else{// parent
        close(fd[1]);
        fcntl(fd[0],F_SETFL,O_NONBLOCK);
        char out[BUFSIZ]={0};
        ssize_t n = read(fd[0],out,sizeof(out));
        if(-1 == n){
            perror("read error");
            return -1;
        }
        printf("parent %d read:%s\n",getpid(),out);
        close(fd[0]);
    }
}

在这里插入图片描述

FIFO管道/命名管道

一.创建命名管道

int mkfifo(pathname,mode);

参数说明：

参数含义
pathname文件路径，文件必须不存在
mode模式

返回值说明：

返回值含义
0成功
非0失败

示例：

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

int main(){
    if(-1 == mkfifo("/tmp/test",0644)){
        perror("mkfifo error");
        return 1;
    }
}

注意：
管道文件通常在/tmp目录下创建。
管道文件大小通常是0

二.打开FIFO文件

int open(const char *path, int mode)；

参数说明：

参数含义
pathname文件路径
mode模式

参数模式说明：

模式含义
O_RDONLY阻塞只读
O_RDONLY/O_NONBLOCK非阻塞只读
O_WRONLY阻塞只写
O_WRONLY/O_NONBLOCK非阻塞只写

返回值说明：

返回值含义
-1失败
其他文件描述符

示例：
阻塞读：

#include <iostream>
#include <unistd.h>
#include <fcntl.h> // open() O_RDONLY
using namespace std;
#define BUFSIZE 258

int main(){
    // 打开命名管道
    int fd = open("/tmp/fifo",O_RDONLY);
    if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
    }else{
        cout << "filo open ok" << endl;
    }
    
    // 读取字符串
    char buffer[BUFSIZE] = {0};
    read(fd,buffer,BUFSIZE);
    
    // 打印读取的字符串
    cout << buffer << endl;
    
    // 关闭管道
    close(fd);
    return EXIT_SUCCESS;
}

阻塞写：

#include <iostream>
#include <fcntl.h> // open() O_WRONLY
#include <unistd.h>
using namespace std;

int main(){
    // 打开命名管道
    int fd = open("/tmp/fifo",O_WRONLY);
    if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
    }else{
        cout << "filo open ok" << endl;
    }
    
    // 读取字符串
    string str;
    getline(cin,str);
    
    // 写入管道
    write(fd,str.c_str(),str.size()+1);
    
    // 关闭管道
    close(fd);
    return EXIT_SUCCESS;
}

写非阻塞:
说明：
只需要在open()添加O_NONBLOCK。
写open()非阻塞，读open()阻塞的情况。读open()需要先执行，否则，写open()会出现No such device or address。

#include <iostream>
#include <fcntl.h> // open() O_WRONLY O_NONBLOCK
#include <unistd.h>
using namespace std;

int main(){
    // 打开命名管道
    int fd = open("/tmp/fifo",O_WRONLY|O_NONBLOCK);
    if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
    }else{
        cout << "filo open ok" << endl;
    }
    
    // 读取字符串
    string str;
    getline(cin,str);
    
    // 写入管道
    write(fd,str.c_str(),str.size()+1);
    
    // 关闭管道
    close(fd);
    return EXIT_SUCCESS;
}

读非阻塞
说明：
只需要在open()添加O_NONBLOCK。
写open()阻塞，读open()非阻塞的情况。读read()需要处理写open()未执行(read()返回0)和读不到数据(写open()打开但是没有写数据，read()返回-1)的情况。

#include <iostream>
#include <unistd.h>
#include <fcntl.h> // open() O_RDONLY O_NONBLOCK
using namespace std;
#define BUFSIZE 258

int main(){
    // 打开命名管道
    int fd = open("/tmp/fifo",O_RDONLY|O_NONBLOCK);
    if(-1 == fd){
        perror("open error");
        return EXIT_FAILURE;
    }else{
        cout << "filo open ok" << endl;
    }
    
    // 读取字符串
    char buffer[BUFSIZE] = {0};
    int n = -1;
    while(n<=0){
        n=read(fd,buffer,BUFSIZE);
    }
    // 打印读取的字符串
    cout << buffer << endl;
    
    // 关闭管道
    close(fd);
    return EXIT_SUCCESS;
}

特点:
可以是非亲缘进程之间
FIFO首先会阻塞在open()，等待读写文件的文件描述符都打开。接着阻塞在read()/write()操作，读写操作需要同时执行。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.4文件描述符复制

在这里插入图片描述

叶书书书书
关注
专栏目录
Linux网络编程——管道通信
Li丶Chong的博客
07-16 472
管道通信分为无名管道和有名管道，无名管道可以用于具有亲缘关系进程间的通信，有名管道克服管道没有名字的限制 管道是Linux支持的最初UNIX IPC形式之一，具有以下特点 管道是半双工的，数据只能想一个方向流动，需要进行双向通讯时需要建立两个管道 只能用与父子进程和兄弟进程之间（具有亲缘关系）的通讯 单独构成一种独立的文件系统，管道对于管道两端的进程来说就是两个文件，但是它不是普通文件，也...
Linux网络编程 - 在服务器端运用进程间通信之管道(pipe)
yunfan
01-10 2164
本文主要讲解进程间通信之一的管道（匿名管道）方式，讨论Linux系统中管道的工作原理及其使用方法，并将管道机制运用在Linux网络编程之中。
网络编程学习笔记之命名管道(上)
liagn的专栏
12-14 661
1,命名管道的命名规范: //server/Pipe/[path]name 2,命名管道的通信模式: 字节模式和消息模式 3,建立一个基本的命名管道服务器: 1) 使用A P I函数C r e a t e N a m e d P i p e，创建一个命名管道实例句柄; 2) 使用A P I函数C o n n e c t N a m e d P i p e，在命名管道实例上监听客户机连接请求
TCP/IP
baidu_17640849的专栏
04-28 555
TCP 与 UDP的区别 TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接 TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保 证可靠交付 TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的 UDP没有拥塞控制，因此网络出现拥塞
Linux系统编程：管道
qq_43598865的博客
06-03 385
匿名管道 1.单工管道(程序进程与shell命令行进程单项通信) 打开管道 FILE* popen(const char* command,const char* open_mode) 参数 含义 command 命令行字符串 open_mode “r"或"w”//只读或只写 返回值 返回值 含义 NULL 文件描述符 非NULL 打开失败 读...
基于C#与MATLAB混合编程的管道缺陷类型识别实验系统软件开发.pdf
06-23
针对该问题,设计并开发了一套基于C#与MATLAB混合编程的管道缺陷类型识别软件,软件利用MATLAB进行数据处理、特征量计算及方法建模等工作,利用C#搭建面向用户的操作界面,发挥二者在软件开发上的独特优势,使用户能快速...
linux系统编程_linux系统编程-中文_
10-04
进程间通信（IPC）也是Linux系统编程的重要部分，包括管道、消息队列、共享内存、信号量和套接字等方法。了解这些机制如何协同工作，可以帮助你设计出高效的多进程和多线程程序。 最后，理解Makefile和构建系统是...
管道网络
qq_26496077的博客
11-28 319
Description Every house in the colony has at most one pipe going into it and at most one pipe going out of it. Tanks and taps are to be installed in a manner such that every house with one outgoing pi...
管道 pipe 半双工/全双工
天煞孤行的专栏
06-24 1790
http://wff8785.blog.163.com/blog/static/89202270201183011145824/
管道为什么是半双工？
qq_41261736的博客
08-16 4654
一、管道是半双工通信的原因 由于Linux一个命令只能完成一个功能，所以一个复杂点的任务需要好几个进程协同完成，第一个进程处理结果需交给第二个进程，然后一次交给第三个，等等，像流水线完成某个商品的生产一样，这个过程只需要数据单向往下传输，所以设计的时候做成了半双工。当然也可以使用管道实现双工通信，需要两个管道。 二、三种通信方式的区别 单工通信：传输方向只有一个方向，单工通信只有一根数据线，...
网络编程（14）—— 进程间通信-管道pipe
Hyman的博客
10-11 2345
Linux中利用管道pipe进行进程间的通信，pipe的函数原型如下： #include int pipe(int pipefd[2]); pipe的参数是一个int型的二维数组，执行完该函数后我们就创建了一个管道，二维数组的两个 元素就分别是管道的输出端（可写）和管道的输出端（可读），我们分别利用write和read函数 进行管道中数据的写和读。 以下代码，先利用fork产生了子进程
基于Linux下C/C++的网络编程之进程(管道和FIFO)
cuixixi0525的博客
09-07 3523
以一个简单的客户—服务器的例子说明管道和FIFO。 对于命名管道的操作与文件操作非常相似，对文件操作中使用的函数read(),write(),close()等函数都可以是用来对管道进行操作。 命名管道的创建：#include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> int mkfifo(const char *pathname, m
Linux进程间通信—管道
梅山
03-27 975
1. 管道 管道的是进程间通信（IPC - InterProcess Communication）的一种方式，管道的本质其实就是内核中的一块内存 (或者叫内核缓冲区)，这块缓冲区中的数据存储在一个环形队列中，因为管道在内核里边，因此我们不能直接对其进行任何操作。 因为管道数据是通过队列来维护的，我们先来分析一个管道中数据的特点： 管道对应的内核缓冲区大小是固定的，默认为 4k（也就是队列最大能存储 4k 数据） 管道分为两部分：读端和写端（队列的两端），数据从写端进入管道，从读端流出管道。 管道中的数据只
进程间通信（IPC机制）——管道
yi_chengyu的博客
09-21 491
1.管道的特点 （1）无论有名还是无名，写入管道的数据都在内存中。 （2）管道是一种半双工通信方式（通信方式有单工（固定接收方发送方，接收方只能接收，发送方只能发送）、半双工（如同对讲机，两端可以切换写入和接收）、全双工（每端都可以接收和写入，且可以同时进行））。 （3）有名和无名管道的区别：有名可以在任意进程间使用，而无名只能在父子进程间。 （4）对于管道，我们只能以只读打开或者只写打开。 （5）有名管道得需要读和写都打开，否则只以读打开或者只以写打开都会阻塞。 （6）管道中没有数据时，读管道read会发
匿名管道 中的 单工通道（popen）
lingfeng2019的博客
05-11 639
本质： 启动shell和命令两个进程，从命令进程中读/写文件流。 解决exec和system无返回输出数据问题。 特点： 方便使用系统自带功能，并可以执行比较复杂的shell。 默认启动两个进程，效率较低。 操作： 打开管道： FILE* popen(const char *command, const char *open_mode); 参数： command： 命令行字符
深入学习：Linux系统编程第二版
"Linux系统编程（第二版）是Robert Love撰写的一本经典IT图书，主要针对Linux系统的编程进行深入探讨。这本书英文版在2013年由O'Reilly Media出版，适合教育、商业或销售推广使用。作者拥有对Linux系统的深厚理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值