管道是一种最基本的IPC机制，由pipe函数创建：
#include <unistd.h> int pipe(int filedes[2]);
调用pipe函数就是在内核区开辟一块缓冲区（称为管道）。filedes[0]指向管道的读端，filedes[1]指向管道的写端。管道实际上就是一个打开的文件。pipe函数成功返回0，失败返回-1.
如何用管道实现两个进程间的通信？
1.父进程调用pipe函数开辟管道，得到两个文件描述符指向管道的两端。
2.父进程调用fork（）创建子进程，那么子进程也有两个文件描述符指向该管道。
3.父进程关闭管道读端,子进程关闭管道写端。父进程可以往管道写,子进程可以从管道
读,管道是环形队列实现的,数据从写端流，从读端流出,这样就实现了进程间通信。
代码实现：
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
int main()
{
int _pipe[2];
int ret = pipe(_pipe);
if (ret == -1){
printf("create pipe error! errno code is : %d\n", errno);
return 1;
}
pid_t id = fork();
if (id < 0){
printf("fork error!");
return 2;
}
else if (id == 0){ //child
close(_pipe[0]);
int i = 0;
char *_mesg_c = NULL;
while (i<100){
_mesg_c = "i am child!";
write(_pipe[1], _mesg_c, strlen(_mesg_c) + 1);
sleep(1);
i++;
}
}
else{ //father
close(_pipe[1]);
char _mesg[100];
int j = 0;
while (j<100){
memset(_mesg, '\0', sizeof(_mesg));
read(_pipe[0], _mesg, sizeof(_mesg));
printf("%s\n", _mesg);
j++;
}
}
return 0;
}使用管道需要注意的4中情况：
1. 如果所有指向管道写端的文件描述符都关闭了(管道写端的引用计数等于0),仍然有
进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像
读到件末尾样。
测试代码：
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
int _pipe[2];
int ret = pipe(_pipe);
if (ret == -1){
printf("create pipe error! errno code is : %d\n", errno);
return 1;
}
pid_t id = fork();
if (id < 0){
printf("fork error!");
return 2;
}
else if (id == 0){ //child
close(_pipe[0]);
int i = 0;
char *_mesg_c = NULL;
while (i<10){
_mesg_c = "i am child!";
write(_pipe[1], _mesg_c, strlen(_mesg_c) + 1);
sleep(1);
i++;
}
close(_pipe[1]);
}
else{ //father
close(_pipe[1]);
char _mesg[100];
int j = 0;
while (j<100){
memset(_mesg, '\0', sizeof(_mesg));
int ret = read(_pipe[0], _mesg, sizeof(_mesg));
printf("%s : code is : %d\n", _mesg, ret);
j++;
}
if (waitpid(id, NULL, 0)< 0)
{
return 3;
}
}
return 0;
}2. 如果有指向管道写端的文件描述符没关闭(管道写端的引用计数大于0),持有管道写
端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数
据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。
测试代码：
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
int _pipe[2];
int ret = pipe(_pipe);
if (ret == -1){
printf("create pipe error! errno code is : %d\n", errno);
return 1;
}
pid_t id = fork();
if (id < 0){
printf("fork error!");
return 2;
}
else if (id == 0){ //child
close(_pipe[0]);
int i = 0;
char *_mesg_c = NULL;
while (i<20){
if (i < 10){
_mesg_c = "i am child!";
write(_pipe[1], _mesg_c, strlen(_mesg_c) + 1);
}
sleep(1);
i++;
}
close(_pipe[1]);
}
else{ //father
close(_pipe[1]);
char _mesg[100];
int j = 0;
while (j<20){
memset(_mesg, '\0', sizeof(_mesg));
int ret = read(_pipe[0], _mesg, sizeof(_mesg));
printf("%s : code is : %d\n", _mesg, ret);
j++;
}
if (waitpid(id, NULL, 0)< 0)
{
return 3;
}
}
return 0;
}3. 如果所有指向管道读端的文件描述符都关闭了(管道读端的引用计数等于0),这时有进
程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终。
测试代码：
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
int _pipe[2];
int ret = pipe(_pipe);
if (ret == -1){
printf("create pipe error! errno code is : %d\n", errno);
return 1;
}
pid_t id = fork();
if (id < 0){
printf("fork error!");
return 2;
}
else if (id == 0){ //child
close(_pipe[0]);
int i = 0;
char *_mesg_c = NULL;
while (i<20){
if (i < 10){
_mesg_c = "i am child!";
write(_pipe[1], _mesg_c, strlen(_mesg_c) + 1);
}
sleep(1);
i++;
}
}
else{ //father
close(_pipe[1]);
char _mesg[100];
int j = 0;
while (j<3){
memset(_mesg, '\0', sizeof(_mesg));
int ret = read(_pipe[0], _mesg, sizeof(_mesg));
printf("%s : code is : %d\n", _mesg, ret);
j++;
}
close(_pipe[0]);
sleep(10);
if (waitpid(id, NULL, 0)< 0)
{
return 3;
}
}
return 0;
}4. 如果有指向管道读端的文件描述符没关闭(管道读端的引用计数大于0),持有管道读
端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时
再次write会阻塞,直到管道中有空位置了才写入数据并返回。
