一、管道概述
1.1、管道概念
管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流（文件IO流）称为一个“管道”。
1.2、管道特点
- 管道是半双工的，数据只能向一个方向流动(单行道)；如果要进行双向通信，必须建立起两个管道（从定义后就不能更改）。
- 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
- 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在于内存中。
- 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且都是从缓冲区的头部读出数据。
1.3、shell中使用管道
shell所做的工作从最终效果上看是这样的：当键盘上输入了数据，会进入这个管道（pipe），这个数据通过管道流向计算机的硬盘或者屏幕或者内存，如果是屏幕则显示出来用户可以看见
1.4、管道创建——pipe函数
功能：创建一无名管道。
头文件：#include <unistd.h>原型：int pipe(int fd[2]);
参数:
fd：文件描述符数组，其中fd[0]表示读端，fd[1]表示写端
返回值:
成功返回0，失败返回错误代码
注意：管道的创建一定要在进程创建之前，例如，父进程一开始就要传递数据，而子进程刚刚开启，这时候才去创建管道的话，数据就接收不到了（管道的存在不代表进程的存在，进程的存在也不一定用到管道，但是管道一定是放在进程中使用的）
1.5、管道应用实例
①通过pipe，父进程给子进程发送数据，在子进程中打印数据（IO流操作的四字箴言“读入写出”）
int main()
{
int pid = 0;
int fdarr[2] = {0};
if (pipe(fdarr)<0)
{
perror("perror");
}
else
{
pid = fork();
if (pid == 0)
{
//读端 关闭写
char buf[30] = { 0 };
close(fdarr[1]);
while (true)
{
read(fdarr[0], buf, 30);
cout << "子进程pid = " << getpid() << "读到数据buf= " << buf << endl;
}
}
else if (pid > 0)
{
//写端 关闭读
close(fdarr[0]);
while (true)
{
write(fdarr[1],"your data is coming!", 30);
sleep(3);
}
}
}
return 0;
}运行结果：
② 父进程中在控制台输入（注意接收的buf和输入的buf要一样大）
运行结果：
③父子进程互相通信（一个程序里面伪聊天）
int main()
{
int pid = 0;
int fdarr[2] = {0};
int fdarr2[2] = { 0 };
if (pipe(fdarr)<0 || pipe(fdarr2) < 0)
{
perror("create pipe perror");
}
else
{
cout << "管道开启成功" << endl;
pid = fork();
if (pid == 0)
{
char buf[100] = { 0 };
close(fdarr[1]);
close(fdarr2[0]);
while (true)
{
read(fdarr[0], buf, 100);
cout << "子进程pid = " << getpid() << "子进程读到数据buf= " << buf << endl;
sleep(3);
cout << "子进程输入： " << endl;
bzero(buf, sizeof(buf));
fgets(buf, sizeof(buf), stdin);//stdin表示控制台输入
write(fdarr2[1], buf, sizeof(buf));
}
}
else if (pid > 0)
{
//读端 关闭写 第一个管道 父给子
close(fdarr[0]);
//写端 关闭读 第二个管道 子给父
close(fdarr2[1]);
while (true)
{
cout << "父进程输入： "<< endl;
char inputBuf[100] = { 0 };
fgets(inputBuf, sizeof(inputBuf), stdin);//stdin表示控制台输入
write(fdarr[1], inputBuf, sizeof(inputBuf));
//write(fdarr[1],"your data is coming!", 30);
sleep(3);
//这里直接对数组进行清空，用来接收子进程传来的数据
bzero(inputBuf, sizeof(inputBuf));
read(fdarr2[0], inputBuf, 100);
cout << "父进程pid = " << getpid() << "父进程读到数据buf= " << inputBuf << endl;
}
}
}
return 0;
}运行结果：
1.5、管道读写规则
①如果试图从管道写端读取数据，或者向管道读端写入数据都将导致错误发生。
②当没有数据可读时，read调用就会阻塞，即进程暂停执行，一直等到有数据来到为止。
③如果管道的另一端已经被关闭，也就是没有进程打开这个管道并向它写数据时，read就会阻塞。
④如果管道的写端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0。
⑤当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。
⑥向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。
1.6、管道的局限性
管道的主要局限性正体现在它的特点上：
① 只支持单向数据流；
② 只能用于具有亲缘关系的进程之间；
③ 没有名字；
④ 管道的缓冲区是有限的（管道存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
⑤ 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须实现约定好数据的格式，比如多少字节算一个消息（或命令、或记录）等待；
二、有名管道——FIFO文件
前言
兄弟进程表示一个main函数中调用两次fork开出来的两个子进程，像上述实现的控制台的伪聊天，其实使用的是匿名管道，只是当前进程内自己跟自己聊天，与实际不符，应该是在两个应用程序里面互相聊天，所以如果想解决这个问题就得使用有名管道
2.1、有名管道概念
管道应用的一个限制就是只能用于具有亲缘关系(父子或兄弟)的进程间通信，如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。FIFO 不同于管道之处在于它提供一个路径名与之关联，以 FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系（不相关）的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信
值得注意的是，FIFO严格遵循先进先出，对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如 lseek() 等文件定位操作。
匿名管道和命名管道的区别
- 匿名管道:1、没有名2、应用在同一个进程fork具有亲缘关系进程内
- 命名管道:1、有名(FIFO文件名）2、可应用在没有任何亲缘关系进程内（两个工程）
2.2、有名管道创建
命名管道可以从命令行上创建，推荐的命令行方法是使用下面这个命令：$ mkfifo filename
命名管道也可以从程序里创建，相关函数如下：
头文件：
#include <sys/types.h>
#include <sys/stat.h>原型：
int mkfifo(const char *pathname, mode_t mode);
int mknod(const char *filename,mode_t mode|S_IFIFO,(dev_t) 0);参数:
pathname: 创建后FIFO名字
mode: 和打开普通文件Open函数的mode参数相同
返回值:
如果第一参数已存在，返回EXIST;
2.3、名管道的打开规则
有名管道比管道多了一个打开操作（open）
FIFO的打开规则：
① 当只写打开FIFO管道时，如果没有FIFO没有读端打开，则open写打开会阻塞。
② FIFO内核实现时可以支持双向通信。（pipe单向通信，因为父子进程共享同一个file结构体）
③ FIFO可以一个读端，多个写端；也可以一个写端，多个读端。
注意：
- 程序不能以O_RDWR模式打开FIFO文件进行读写。
- 如果确实需要在程序之间双向传递数据的话，我们可以同时使用一对FIFO或管道，一个方向配一个；还可以用先关闭再重新打开FIFO的办法明确地改变数据流的方向。
三、有名管道伪聊天实现
首先在解决方案中（新建项）创建两个工程（writeMain.cpp为写，readMain.cpp为读）
1、代码
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <iostream>
#include <string.h>//bzero
#include <sys/types.h>//O_WRONLY
#include <sys/stat.h>
using namespace std;
int main()
{
int writefd;
char buf[50] = { 0 };
umask(0);
//先尝试访问这个文件看是否存在，没有则创建
if (access("/root/projects/a_to_b.fifo",F_OK) == -1)
{
if (mkfifo("/root/projects/a_to_b.fifo", 0777) == -1)
{
perror("mkfifo error");
}
}
else
{
cout<<"文件存在" << endl;
}
//打开管道文件
writefd = open("/root/projects/a_to_b.fifo", O_WRONLY);//一端写另一端读
while (true)
{
cout << "请输入： " << endl;
fgets(buf, sizeof(buf), stdin);
cout << "buf = " << buf << endl;
int res = write(writefd, buf, sizeof(buf));
cout << "res = " << res << endl;
}
return 0;
}
int main()
{
int readfd;
char buf[50] = { 0 };
umask(0);
//先尝试访问这个文件看是否存在，没有则创建
if (access("/root/projects/a_to_b.fifo", F_OK) == -1)
{
if (mkfifo("/root/projects/a_to_b.fifo", 0777) == -1)
{
perror("mkfifo error");
}
}
else
{
cout << "文件存在" << endl;
}
//打开管道文件
readfd = open("/root/projects/a_to_b.fifo", O_RDONLY);
while (true)
{
//fgets(buf, sizeof(buf), stdin);
int res = read(readfd, buf, sizeof(buf));
cout << "res = " << res << endl;
cout << "buf = " << buf << endl;
}
return 0;
}
2、运行效果
ubuntu中同时运行两个工程，命令如下
g++ writeMain.cpp -o w
./w
因为FIFO文件是管道文件，而不是普通文件。如果只是单纯用写方式打开一端的管道，另一端没有打开去读，就会阻塞（可能连管道文件都打不开，循环都进不去），直到另一端开始读，这端的open才能成功，程序才会继续往下走。（即管道一定是有一端写，另一端读）
运行工程后，在ubuntu中打开管道文件你会发现它的大小为0字节，因为这个管道文件只是在两个应用程序中搭起的桥梁（中转站、介质），数据只是经过它，而不是保存下来，管道就像水管，两端有阀门，如图（也可以把三者想象成 家、火车站、学校宿舍， 你在家或者学校宿舍睡觉而不会在火车站睡觉）
管道——半双工——单向——有源头和目的地 （如上述的writeMain.cpp、readMain.cpp）
口诀:没有名字是家人（匿名管道针对有亲缘关系的进程），会叫名字不是家人
原创不易，转载请注明出处：