本期主题：
unix环境高级编程——进程间通信之管道
当从一个进程连接数据流到另一个进程时，使用术语管道（pipe）。
管道是UNIX系统中IPC的最古老形式，所有UNIX都提供这种通信机制。对于大多数linux用户来说，管道在shell中其实非常熟悉，很多命令的连接就是通过管道来完成的。例如
$ cmd1 | cmd2
带着这两个问题思考，理解后面UNIX发展的FIFO和socket是怎么解决这两个问题的。
这一章主要描述在单个进程中的管道。
NAME
popen, pclose - pipe stream to or from a process
SYNOPSIS
#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
popen函数允许一个进程启动另外一个进程，并且可以通过管道读或者写这个新进程的数据，command参数就是要运行的程序，type参数就是r或者w，代表是要读还是写这个进程。
popen返回的是FILE文件流指针，可以用标准IO （fread、fwrite）等去操作。
看一个例子，使用popen从读取"uname -a"命令的所有信息。
#include <stdio.h>
int main(void)
{
int char_bytes = 0;
FILE *read_fp;
char char_buf[1024] = { 0 };
read_fp = popen("uname -a", "r");
char_bytes = fread(char_buf, sizeof(char), 1024, read_fp);
if (char_bytes > 0)
{
printf("pipe read is \n %s \n", char_buf);
}
pclose(read_fp);
}
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out
pipe read is
Linux ubuntu 5.11.0-34-generic #36~20.04.1-Ubuntu SMP Fri Aug 27 08:06:32 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux
从上面的例子可以看出，使用popen有一个弊端：
每次的popen调用，既需要启动 使用popen调用的程序，还需要再启动一个 shell（例如上面这个例子里的"uname -a"），这样导致了popen将启动两个进程，从系统资源角度来看，popen的调用成本高。
因此引出了 pipe函数，pipe函数不需要启动shell.
pipe函数原型：
NAME
pipe — create an interprocess channel
SYNOPSIS
#include <unistd.h>
int pipe(int fildes[2]);
输入参数是两个文件描述符，即在这两个文件描述符间建立管道。
注意：这个接口只能从fd[1]写，然后从fd[0]读，不能反过来，反过来可能会发生未定义的错误。
Data can be written to the file descriptor fildes[1] and read from the file descriptor fildes[0]. A read on the file descriptor fildes[0] shall access data written to the file
descriptor fildes[1] on a first-in-first-out basis. It is unspecified whether fildes[0] is also open for writing and whether fildes[1] is also open for reading.
看下面这个例子，如果从fd[1]写，从fd[0]读，会有问题
int main(void)
{
int fd[2];
int data_bytes = 0;
if (pipe(fd) == 0)
{
printf("pipe sucessful. \n");
char data[] = "hello world";
char buff[1024];
memset(buff, '\0', sizeof(buff));
data_bytes = write(fd[0], data, strlen(data));
printf("write data bytes %d\n", data_bytes);
data_bytes = read(fd[1], buff, 1024);
printf("read data bytes %d\n", data_bytes);
printf("read is %s\n", buff);
}
else
{
printf("pipe failed. \n");
}
}
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out
pipe sucessful.
write data bytes -1
read data bytes -1
read is
如果调换一下写和读，则输出正确结果
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out
pipe sucessful.
write data bytes 11
read data bytes 11
read is hello world
上面这个例子是在单个进程中进行管道通信，用下图可以表示
前面我们所讲的还是在单个进程之间的管道，管道的真正优势体现在，当你想在两个进程之间传递数据的时候。
当程序用fork调用产生新进程时，原来的文件描述符仍然是保持着打开状态，因此如果在原来的进程中先建立好管道，再使用fork，这样就能保证新进程中也有管道，即可通过管道在两个进程中传递数据。
看一个实际的例子，先建立管道，然后父进程中写，子进程中读：
int main(void)
{
int fd[2];
int data_bytes = 0;
char data[] = "hello world";
char buff[1024];
memset(buff, '\0', sizeof(buff));
pid_t fork_result;
if (pipe(fd) == 0)
{
printf("pipe sucessful. \n");
fork_result = fork();
if (fork_result < 0)
{
printf("fork failed!\n");
}
else if (fork_result == 0)
{
pid_t child_pid;
child_pid = getpid();
data_bytes = read(fd[0], buff, 1024);
printf("pid is %d, child process,read is %s\n", child_pid,buff);
}
else
{
int status;
pid_t parent_pid;
pid_t wpid;
parent_pid = getpid();
data_bytes = write(fd[1], data, strlen(data));
wpid = wait(&status); //等待子进程结束
printf("pid is %d, parent process, wpid is %d\n", parent_pid, wpid);
}
}
}
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out
pipe sucessful.
pid is 20888, child process,read is hello world
pid is 20887, parent process, wpid is 20888
FIFO也被称为命名管道，前面我们所提到的管道是无名管道，这两种管道之间的主要差别在于：
无名管道只能在相关的进程之间通信，即这两个进程需要有共同的祖先，而FIFO管道可以在不相关的进程之间也交换数据。
shell中有命令能够创建FIFO，mkfifo命令
名称
mkfifo - 创建 FIFO（命名管道）
概述
mkfifo [选项]... 名称...
描述
使用给定的名称创建命名管道（FIFO）。
//看个具体的例子
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ mkfifo test_fifo
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ls -lF test_fifo
prw-rw-r-- 1 jason jason 0 Nov 6 09:47 test_fifo|
//文件类型p和最后的|符号，代表这是一个管道
也可使用API来创建FIFO
mkfifo, mkfifoat - make a FIFO special file (a named pipe)
SYNOPSIS
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
FIFO在linux系统中其实也是一种文件，不过是管道类型的特殊文件，这个与前面讲的pipe不同，pipe函数的参数是文件描述符，而这里的FIFO是一个文件，需要用过文件IO的接口open来打开，从而获取到文件描述符。
1.看一个简单例子，直接访问FIFO文件
通过cat直接访问FIFO文件
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ cat test_fifo&
[1] 21881
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ echo "helloworld" > test_fifo
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ helloworld
[1]+ 已完成 cat test_fifo
可以看出这是一个阻塞式的行为，需要把cat test_fifo命令放在后台运行，直到有写这个FIFO的，才能读取出来。
2.使用open方式打开管道
使用open方式打开FIFO管道有两个特点：
1.程序不能以O_RDWR模式打开FIFO文件进行读写操作，因为FIFO通常是用来传递单向数据；
2.open_flag加上O_NONBLOCK标志位与否，对应的现象不一样，具体看下面两个例子：
open的使用有两种标志位，一种是非阻塞标志位，另外一种是阻塞标志位，默认就是阻塞状态。
（1）使用默认模式（阻塞模式）的demo：
结论：使用该模式时，open会阻塞在打开FIFO，需要有一个进程读，另一个进程写，先打开的会阻塞住；
下面的例子，读的进程后台运行，阻塞住了，直到写的进程开始运行；
int main(int argc, char *argv[])
{
int i = 0;
int open_mode = 0;
int fd = 0;
int ret = 0;
if (argc < 2)
{
printf("Wrong, too less argv!\n");
return -1;
}
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "O_RDONLY") == 0)
{
open_mode |= O_RDONLY;
}
if (strcmp(argv[i], "O_WRONLY") == 0)
{
open_mode |= O_WRONLY;
}
if (strcmp(argv[i], "O_NONBLOCK") == 0)
{
open_mode |= O_NONBLOCK;
}
}
printf("process %d opening fifo\n", getpid());
ret = open("test_fifo", open_mode);
if (ret < 0)
{
printf("wrong fd!\n");
return -1;
}
printf("process %d exit, ret is %d\n", getpid(), ret);
}
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out O_RDONLY&
[1] 25167
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ process 25167 opening fifo
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out O_WRONLY
process 25168 opening fifo
process 25167 exit, ret is 3
process 25168 exit, ret is 3
[1]+ 已完成 ./a.out O_RDONLY
（2）使用非阻塞模式：
结论：使用非阻塞模式，open不会等待，而会立即返回；
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ ./a.out O_RDONLY O_NONBLOCK &
[1] 25314
jason@ubuntu:~/WorkSpace/0.Unix_AP/15.pipe$ process 25314 opening fifo
process 25314 exit, ret is 3