Linux进程学习之：管道通信

概述

管道是流行的进程间通信机制，使用了虚拟文件系统对象。
管道只能单向通信，如果要实现双向通信，就得再开辟一个新的管道出来
管道分为无名管道和有名管道，无名管道只能在具有血缘关系的进程间通信，有名管道可以在多进程之间通信

管道由pipe函数创建，函数声明如下：

/* Create a one-way communication channel (pipe).
   If successful, two file descriptors are stored in PIPEDES;
   bytes written on PIPEDES[1] can be read from PIPEDES[0].
   Returns 0 if successful, -1 if not.  */
extern int pipe (int __pipedes[2]) __THROW __wur;

pipe函数的参数是一个数组大小为二的一维数组，如果创建成功，两个文件描述符存储在管道里面，管道１只能写入，管道０只能读取，返回０代表创建成功，－１代表创建失败。

调用pipe函数后，系统会在内存中开辟一段内存，大小有待研究，这段内存成为管道，他有一个写端和读端。具体写的时候是如何写的目前还不清楚，读也是。

在创建子进程之前先创建管道，这样在创建子进程最后，子进程就会复制父进程的全部资源，包括管道的两个文件描述符。

1. 如果所有指向管道写端的文件描述符都关闭了,而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样

2. 如果有指向管道写端的文件描述符没关闭，而持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回

3. 如果所有指向管道读端的文件描述符都关闭了,这时有进程指向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止

4. 如果有指向管道读端的文件描述符没关闭,而持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再write会阻塞,直到管道中有空位置了才写入数据并返回
   （copy from https://www.cnblogs.com/MrListening/p/5858358.html）

coding

无名管道：

#include <iostream>
#include <unistd.h>
#include <string>
#include <stdlib.h>

using namespace std;

int main()
{
    int fd[2];
    if (pipe(fd)){
        cout << "create pipe failed" << endl;
    }
    pid_t pid;
    pid = fork();
    if (pid > 0){
        cout << "This is the parent: " << pid << endl;
        string wStr = "hello world!";
        write(fd[1], wStr.data(), wStr.size());
        sleep(10);
        close(fd[1]);
        exit(0);
    }
    if (pid == 0){
        cout << "This is the child: " << pid << endl;
        char rStr[128] = {'\0'};
        read(fd[0], rStr, sizeof (rStr));
        cout << rStr << endl;
        read(fd[0], rStr, sizeof (rStr));
        close(fd[0]);
        exit(0);
    }
    if (pid < 0){
        cout << "fail to fork" << endl;
        exit(1);
    }
    return 0;
}

有名管道

无名管道只能在具有血缘关系的进程间通信，而有名管道则可以在任意两个进程间通信。

首先，需要使用mkfifo函数生成一个管道文件，然后在两个进程中都使用open函数打开，然后就可以一个进程往管道写，一个管道读了。mkfifo 函数包含在sys/stat.h头文件中，函数声明如下：

/* Create a new FIFO named PATH, with permission bits MODE.  */
extern int mkfifo (const char *__path, __mode_t __mode)
     __THROW __nonnull ((1));

两个参数，第一个是路径，第二个是权限，一般的使用方法是

int ret = mkfifo("./myfifo", 0777);
if (ret < 0)
	cout << "create myfifo failed" << endl;
else
	cout << "create myfifo successfully" << endl;

上面的代码创建了一个名为myfifo的管道文件。

全部代码是：

#include <iostream>
#include <unistd.h>
#include <sys/stat.h>
 
using namespace std;
 
int main(){
    int ret = mkfifo("./myfifo", 0777);
    if (ret < 0)
        cout << "create myfifo failed" << endl;
    else
        cout << "create myfifo successfully" << endl;
    return 0;
}

接下来需要创建两个文件，一个负责写入信息，一个负责读取信息

首先是写入信息的文件，这个文件中，我们首先要以只写方式打开管道文件，然后往里面写内容

 #include <iostream>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 using namespace std;
 
 int main(){
     int fd = open ("./myfifo", O_WRONLY);　// O_WRONLY 包含在fcntl.h头文件中
     if (fd < 0){
         cout << "open myfifo failed" << endl;
         return -1;
     }
     cout << "open myfifo successfully" << endl;
     sleep(10);  // sleep函数包含在 stdlib.h 头文件中
     char signal = '1';
     write(fd, &signal, sizeof(signal));  // write 函数包含在unistd.h头文件中
     cout << "writed signal" << endl;
     return 0;
 }

注意：如果运行出错的话，删掉注释试一下

上述代码解释：首先打开管道文件，并打印打开成功与否信息，休眠十秒后往管道内写入信息，休眠的目的是当运行读管道内容的进程时，可以明显看出，当管道内没有内容可读时，读进程将会被阻塞，直到写进程在管道写入了信息。

接下来是读进程的代码：

 #include <iostream>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 
 using namespace std;
 
 int main(){
     int fd = open("./myfifo", O_RDONLY);
     if (fd < 0){
         cout << "open myfifo file failed" << endl;
         return -1;
     }
     cout << "open myfifo file successfully" << endl;
     char signal[] = {"0"};
     read (fd, signal, sizeof(signal));
     cout << "read signal " << signal << endl;
     return 0;
 }

此代码相关注释可以参考写进程代码的注释

运行的时候，在第一个终端运行写进程代码，第二个终端运行读进程代码，可以看出在写进程睡眠十秒之后，往管道内写入了信息，此时阻塞的读进程被激活并读取管道内的信息。

此处，提个问题，读进程是如何知道管道被写入信息的？