根据上节所讲就可以了解到：管道其实就是实现进程间通讯IPC中的一种类型方法
基本概念（无名管道）
管道是一种最基本的IPC机制，通常指无名管道，也是UNIX系统IPC最古老的形式。管道只能作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：
- 其本质是一个伪文件(实为内核缓冲区)，可以使用普通的read,write等函数进行读写
- 由两个文件描述符引用，一个表示读端，一个表示写端
- 规定数据从管道的写端流入管道，从读端流出
管道的原理
管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
管道的局限性
- 数据一旦被读走，便不在管道中存在，不可反复读取
- 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动
所谓半双工，其实在讲串口的时候就提到过，也就是同一时间要么只能写要么只能读，不能同时写和读。 对于进程通讯就是：父进程写的时候子进程只能读；子进程写的时候父进程只能读。
- 只能在有公共祖先的进程间使用管道
（ 常见的通信方式有，单工通信、半双工通信、全双工通信 ）
pipe函数（无名管道)
当成功调用pipe函数时，会创建两个文件描述符，fd[0] -> 读(r），fd[1]-> 写(w)，之后如果想要向管道写数据就往fd[1]里面写，如果想从管道读数据就从fd[0]里面读！
如果要关闭管道，只需要关闭这两个文件描述符就可以了。
需要添加的库
#include <unistd.h>函数原型
int pipe(int pipefd[2]);函数参数
- pipefd[2]：表示一个包含两个文件描述符的数组，也就是上面提到分别代表读和写的 fd[0] 和 fd[1]
- 返回值：若成功返回0，失败则返回-1
实操演示
创建一个名为'IPC"的文件夹，关于各种IPC的学习代码都放在这个文件夹下：
注意，由于fork函数会拷贝一份一样的程序给子进程，所以管道的创建应该在fork之前，这样父子进程就都有了fd[0]和fd[1]，并且由于管道指向内核，所以父子进程的fd[0]和fd[1]是相同的。
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
int fd[2];
pid_t fork_return;
char *writebuf = "mjmmjmmm";
char readbuf[1024] = {0};
if(pipe(fd) == -1){
printf("pipe error\n");
}
fork_return = fork();
if(fork_return > 0){//father
close(fd[0]);
//ssize_t write(int fd, const void *buf, size_t count);
write(fd[1],writebuf,strlen(writebuf));
wait(NULL);
}else if(fork_return == -1){//error
printf("fork error\n");
}else{//son
close(fd[1]);
//ssize_t read(int fd, void *buf, size_t count);
read(fd[0],&readbuf,1024);
printf("read from pipe:%s\n",readbuf);
exit(1);
}
return 0;
}实现效果
基本概念（有名管道）
FIFO，也称为命名管道，它是一种文件类型。
有名管道的特点
- FIFO可以在无关的进程之间交换数据，与无名管道不同
- FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中
mkfifo函数（有名管道）
需要添加的库
#include <sys/stat.h>函数原型
int mkfifo(const char *pathname, mode_t mode);函数参数
- pathname：文件路径
- mode：mode 参数与
open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它
关于open函数中的mode:
其中较为常用的是：
- S_IRWXU：对主用户来说可读，可写，可执行
- S_IRUSR：对主用户来说可读
- S_IWUSR：对主用户来说可写
- S_IXUSR：对主用户来说可执行
详见：Linux 系统编程 开篇/ 文件的打开/创建_mjmmm的博客-CSDN博客
- 返回值：成功返回0，出错返回-1
既然可以用一般文件的I/O函数操作它，就意味可以使用open来打开，而open中的第二个参数flag中有一个选项是“
O_NONBLOCK”，这是非阻塞标志：
若没有指定
O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。若指定了
O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。参考：进程间通信（一）管道的pipe函数 FIFO的mkfifo函数_mkfifo 多进程_点灯小哥的博客-CSDN博客
实操演示
FIFO的通讯方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”
fifo1.c：（只读open FIFO，并不设“O_NONBLOCK”）
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
int main()
{
if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST) //如果创建失败 且 没有已存在的FIFO
{
printf("mkfifo failed\n");
perror("why");
}
int fd = open("./fifo",O_RDONLY); //only read
printf("open success\n");
return 0;
}实现效果1：
可见，由于没有设置O_NONBLOCK，且没有进程只写打开FIFO，所以只读打开FIFO会一直阻塞
fifo2.c：（只读open FIFO，并设置“O_NONBLOCK”）
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
int main()
{
if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
{
printf("mkfifo failed\n");
perror("why");
}
int fd = open("./fifo",O_RDONLY|O_NONBLOCK); //only read
printf("open success\n");
return 0;
}实现效果2：
可见，由于加上了O_NONBLOCK，虽然没有进程只写打开FIFO，但是只读打开不会阻塞而是立刻返回，并执行了printf
fifo3.c & fifo4.c：（创建两个进程，fifo3一直写，fifo4一直读）
fifio3.c：（一直写）
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
int main()
{
char *str = "mjmmmmjjm";
int fd = open("./fifo",O_WRONLY); //only write
printf("open success\n");
while(1){
write(fd,str,strlen(str));
sleep(1);
}
close(fd);
return 0;
}fifo4.c：（一直读）
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
char buf[30] = {0};
int nread = 0;
if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
{
printf("mkfifo failed\n");
perror("why");
}
int fd = open("./fifo",O_RDONLY); //only read
printf("read open success\n");
while(1){
read(fd,&buf,30);
printf("read %d byte from fifo,context: %s\n",nread,buf);
}
close(fd);
return 0;
}实现效果3：
先编译并运行fifo4.c：
可见没有进程只写打开FIFO，所以一直阻塞
然后再新的窗口编译并运行fifo3.c：
此时有进程只写打开FIFO并每隔一秒向其中写入数据
此时再观察fifo4.c的输出：
此时只读FIFO不再阻塞，并每隔一秒读到只写FIFO写入的数据！
上述例子可以扩展成 客户进程—服务器进程 通信的实例，负责写的fifo3.c的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，负责读的fifo4.c类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：
