进程间通信—管道

1. 管道

Linux 使用fork创建子进程，父进程与子进程并不共享堆栈段和数据段，他们之间通过管道进行通信。管道是一种两个进程之间进行单向通信的机制。管道称为半双工管道。管道具有以下特点：

(1) 数据只能由一个进程流向另一个进程（一个读管道，一个写管道），如果需要进行全双工通信，需要建立两个管道。

(2) 管道只能用于父子进程或者兄弟进程间的通信。

除了以上的局限性，管道还有一些不足

(1) 管道没有名字（无名管道）。

(2) 管道的缓冲区大小是受限制的。

(3) 管道所传输的是无格式的字节流。

使用管道通信时，两端的进程向管道读写数据是通过创建管道时，系统设置的文件描述符。通过管道通信的两个进程，一个向管道写数据，每次写到管道缓冲区的末尾，一个从管道读数据，每次从管道缓冲区头读出数据。

管道使用pipe()函数创建，函数原型如下:

#include <unistd.h>
int pipe(int pipefd[2]);

管道的两端分别用描述符pipefd[0]和pipefd[1]来表示。但是两端的读写是固定的，即一端只能用于读，pipefd[0]。另一端只能用于写，pipefd[1]。

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
using namespace std;

static void signal_child(int siginfo) {

    int status;
    pid_t child;
    if (siginfo == SIGCHLD) {
        child = wait(&status);
        cout << "parent wait" << endl;
    }
}
int main(void) {

    int fd[2];
    pid_t pid;
    char c;

    pipe(fd);
    signal(SIGCHLD, signal_child);
    if ((pid = fork()) < 0) {
        cerr << "fork erro" << endl;
        exit(-1);
    }
    if (pid == 0) {
        close(fd[0]);
        write(fd[1], "C", 1);
    }
    else {
        //sleep(1);
        close(fd[1]);
        if (read(fd[0], &c, 1) < 0) {
            cerr << "parent read error" << endl;
            exit(-1);
        }
        cout << "parent read " << c << endl;
    }
    exit(0);
}

父子进程fork创建子进程，并将已打开的描述符复制到子进程中。

父进程需要关闭写管道，子进程需要关闭读管道。

由于子进程可能早于父进程先执行完毕，于是使用signal函数检测是否SIGCHLD信号，而该信号默认是忽略，因此需要添加一个信号处理函数，完成父进程对子进程的回收，避免产生僵尸进程。

2. FIFO

由于管道没有名字，它只能用于具有亲缘关系的进程间通信。使用有名管道FIFO，可以完成无亲缘关系的进程相互通信。FIFO提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中。  

FIFO特点如下：
(1) 可以使连个不具有亲缘关系的两个进程实现通信。

(2) 该管道可以通过路径名指出，并且在文件系统是可见的。在简历关到后，两个进程就可以把它当作文件，进行读写操作。

(3) FIFO严格遵循了先进先出规则。从缓冲区头部进行读操作，写操作将数据添加到缓冲区尾部。

FIFO使用mkfifo()函数创建，函数原型如下：

int mkfifo(const char* pathname, mode_t mode)

pathname为FIFO的路径名，mode为创建该文件当前用户，用户组，其他用户的读写可执行权限。如果当前路径已经存在了FIF0文件，返回EEXIST操作。

读管道程序mkfifo_r.cpp，将对管道的读操作设置为非阻塞。

#include <iostream>
#include <cstdio>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
using namespace std;

#define P_FIFO "/tmp/p_fifo"
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

int main(void) {

    char cache[100];
    int fd;

    if (access(P_FIFO, F_OK) == 0) {  // 判断文件是否存在 
        execlp("rm", "-f", P_FIFO, NULL);  // 存在并删除
        cout << "access" << endl;
    }
    
    if (mkfifo(P_FIFO, FILE_MODE) < 0) 
        cout << "Createnamed pipe failed" << endl;
 
    fd = open(P_FIFO, O_RDONLY | O_NONBLOCK);
    while(1) {
        memset(cache, 0, sizeof(cache)); // 每次清空缓冲区，避免与下一次接受的混乱
        if (read(fd, cache, 100) == 0) 
            cout << "no data" << endl;
        else 
            cout << "get data " << cache << endl;
        sleep(1);
    } 
    close(fd);
}

写操作mkfifo_w.cpp如下：

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

#define P_FIFO "/tmp/p_fifo"
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) 

int main(int argc, char** argv) {

    if (argc < 2) {
        cout << "usage : a.out data" << endl;
        return 0;
    }
    int fd;
    fd = open(P_FIFO, O_WRONLY | O_NONBLOCK);
    write(fd, argv[1], sizeof(argv[1]));
    close(fd);
}    

下面关于管道或者FIFO的读出与写入的若干规则

(1) 如果请求读出的数据量多于管道或FIFO中当前可用数据量，那么只返回这些可用的数据。

(2) 如果请求写入的数据的字节数小于或等于PIPE_BUF，那么write保证原子。如果有两个进程同时网一个管道或FIFO写，先写入第一个进程的数据，在写入第二个进程的数据，或者相反。不会出现两个进程的数据混杂在一起被写入到管道或FIFO。如果请求写入的字节大于PIPE_BUF，write操作不能保证原子。

(3)  O_NONBLOCK标志的设置对write操作的原子性并没有影响。原子性完全是由所请求字节数是否小于等于PIPE_BUF决定的。然而当一个管道或FIFO设置成非阻塞时，来自write的返回值取决于待写的字节数以及管道或FIFO当前可用空间大小。如果待写字节数小于等于PIPE_BUF：

a.  如果管道或FIFO有足够的字节存放请求的字节数，所有字节都写入。

b.  如果该管道或FIFO剩余的空间不足以存放请求的字节，那么立即返回一个EAGAIN错误。因为设置了O_NONBLOCK，进程不会被阻塞。但是内核无法在接受部分数据的同时仍保证write操作的原子性。，于是它必须返回一个错误。

如果待写的字节数大于PIPE_BUF：

a.  如果该管道或FIFO至少有1字节空间，那么内核写入该管道或FIFO能容纳数目的数据字节，同时返回写入的字节数。

b.  如果管道或者FIFO满了，那么立即返回一个EAGAIN错误。

(4) 如果向一没有为读打开的管道或FIFO写入时，那么内核将产生一个SIGPIPE信号，