在C/C++中，我们是利用一个含有两个文件描述符的数组来表示一根管道，通常使用fd[1]来读，fd[2]来写。而Python中则是由multiprocessing.Pipe()直接创建两个描述符，直接用就行。刚开始用Python时，我误以为Python中的管道是全双工的，这是错误的。管道都是半双工的，你在一端读的时候，一端只能写。不可能同时进行。

本文代码实现父进程和子进程对话，对话顺序是通过C中的read或者Python中的recv函数阻塞特性实现的。你一句我一句，不会乱顺序。

头文件：

#ifndef _UTILI_H
#define _UTILI_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#define err_quit(m) \
		do{ \
			perror(m); \
			exit(1); \
		}while(0)
#define MAXLINE 512

#endif

实现：

#include "utili.h"

void child_handler(int *fd1, int *fd2, char **chls);
void parent_handler(int *fd1, int *fd2, char **pars);

int main()
{
	char* parent_say[] = {"hello", "how old are you", "me too,bye", NULL};
	char* child_say[] = {"hi", "i'm fine,and you?", "byebye", NULL};
	
	int fd1[2];    //use fd[1] which is for reading, another is for writing
	int fd2[2];    //like the above
	
	if(pipe(fd1) == -1 || pipe(fd2) == -1)
		err_quit("create pipe err.\n");
	
	pid_t pid;
	if( (pid = fork()) < 0)   //C还是很坑的，第一次在这写成了==，这个错误愣是害我找了半天
		err_quit("fork err.\n");
	else if(pid == 0){
		child_handler(fd1, fd2, child_say);
		exit(0);
	}
	
	parent_handler(fd1, fd2, parent_say);

	int status;
	wait(&status);

	return 0;
}

void child_handler(int *fd1, int *fd2, char **chls)
{
	close(fd1[1]);
	close(fd2[0]);
	
	char buff[MAXLINE];
	for(int i=0; *(chls+i) != NULL; ++i){
		read(fd1[0], buff, sizeof(buff));
		printf("parent say:>%s\n", buff);

		write(fd2[1], *(chls+i), strlen(*(chls+i))+1);
	}
	
	close(fd1[0]);
	close(fd2[1]);
}

void parent_handler(int *fd1, int *fd2, char **pars)
{
	close(fd1[0]);
	close(fd2[1]);

	char buff[MAXLINE];
	for(int i=0; *(pars+i) != NULL; ++i){
		write(fd1[1], *(pars+i), strlen(*(pars+i))+1);

		read(fd2[0], buff, sizeof(buff));
		printf("child say:>%s\n", buff);
	}
	
	close(fd1[1]);
	close(fd2[0]);
}

import multiprocessing

parent_say = ('hello', 'how old are you', 'me too,bye')
child_say = ('hi', 'i am fine,and you?', 'bye')

def child_handler(read_fd, write_fd):
	for word in child_say:
		print 'child say:>' + (read_fd.recv())
		write_fd.send(word)

def parent_handler(read_fd, write_fd):
	for word in parent_say:
		write_fd.send(word)
		print 'parent say:>' + (read_fd.recv())

if __name__ == '__main__':
	(read_fd1, write_fd1) = multiprocessing.Pipe()
	(read_fd2, write_fd2) = multiprocessing.Pipe()
	child = multiprocessing.Process(target=child_handler, args=(read_fd1, write_fd2))
	child.start()

	parent_handler(read_fd2, write_fd1)

	read_fd1.close()
	read_fd2.close()
	write_fd1.close()
	write_fd2.close()

	child.join()

管道操作的原子性：

系统加于管道和FIFO的唯一限制为：

• OPEN_MAX     一个进程在任意时刻打开的最大描述符数（Posix要求至少为16）。
• PIPE_BUF        可原子性地写往一个管道或FIFO的最大数据量（Posix要求至少为512）。