linux 管道
管道(pipe)：最基本的IPC机制，单向通信
管道是Linux中很重要的一种通信方式,是把一个程序的输出直接连接到另一个程序的输入,常说的管道多是指无名管道,无名管道只能用于具有亲缘关系的进程之间，这是它与有名管道的最大区别。
1、分类：
（1）、管道（无名管道）：pipe 管道是用环形队列实现的
#include <unistd.h>
int pipe(int filedes);
pipe 函数：filedes参数传出给用户程序两个文件描述符（filedes指向管道的读端,filedes指向管道的写端）
通过read(filedes)或者write(filedes)，向这个文件读写数据其实是在读写内核缓冲区。
pipe函数调用成功返回0,调用失败返回-1。
步骤：1.创建管道; 2.fork创建子进程;
3.父子各关闭不需要的进程描述符(可利用read()、write())。
（2）、命名管道（有名管道）：FIFO
创建：
#include <sys/types.h>
#include <sys/stat.h>
int mknod(const char *path,mode_t mod,dev_t dev);
int mkfifo(const char *path,mode_t mode);
调用成功都返回0，失败都返回－1
2、管道大小及工作特点：
在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：
限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节（4096字节），使得它的大小不象文件那样不加检验地增长。
使用单个固定缓冲区也会带来问题。即：管道满时，写阻塞；空时，读阻塞。
注：从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。
3、管道的环形队列：
管道是由内核管理的一个缓冲区，相当于我们放入内存中的一个片段。
管道的一端连接一个进程的输出，这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。一个缓冲区不需要很大，它被设计成为环形的数据结构，以便管道可以被循环利用。
管道空时，读等待；管道满时，写等待；当两个进程都终结的时候，管道也自动消失。
4、管道的实现方式：
管道：单向通信
创建管道，并执行通信：
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/wait.h>
int main()
{
int _pipe_fd={-1,-1};//create pipe
if(pipe(_pipe_fd) < 0)
{
perror("pipe");
exit(1);
}
pid_t _pid=fork();//create init
if(_pid < 0)
{
perror("fork");
exit(2);
}
else if(_pid == 0)//Child
{
close(_pipe_fd);//close child read
int count=10;//child write
char buf[]="hello friends";
while(count--)
{
write(_pipe_fd,buf,strlen(buf));
sleep(1);
}
//close(_pipe_fd);//close child write
exit(0);//exit can return and close file by itself
}
else//Father
{
close(_pipe_fd);//close father write
char buf;//father read
while(1)
{
memset(buf,'\0',sizeof(buf));
ssize_t _size=read(_pipe_fd,buf,sizeof(buf)-1);
if(_size > 0)
{
buf='\0';
printf("%s\n",buf);
}
else if(_size == 0)
{
printf("Pipe is empty,child quit\n");
exit(3);
}
}
}
return 0;
} 运行结果:
（1).如果所有指向管道写端的文件描述符都关闭了(管道写端的引用计数等于0),而仍然有
进程 从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像
读到文件末尾一样。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/wait.h>
int main()
{
int _pipe_fd={-1,-1};//create pipe
if(pipe(_pipe_fd) < 0)
{
perror("pipe");
exit(1);
}
pid_t _pid=fork();//create init
if(_pid < 0)
{
perror("fork");
exit(2);
}
else if(_pid == 0)//Child
{
close(_pipe_fd);//close child read
int count=10;//child write
char buf[]="hello friends";
while(count--)
{
write(_pipe_fd,buf,strlen(buf));
sleep(1);
}
//close(_pipe_fd);//close child write
exit(0);//exit can return and close file by itself
}
else//Father
{
close(_pipe_fd);//close father write
char buf;//father read
while(1)
{
memset(buf,'\0',sizeof(buf));
ssize_t _size=read(_pipe_fd,buf,sizeof(buf)-1);
if(_size > 0)
{
buf='\0';
printf("%s\n",buf);
}
else if(_size == 0)
{
printf("Pipe is empty,child quit\n");
exit(3);
}
}
}
return 0;
} 运行结果：
（2）.如果有指向管道写端的文件描述符没关闭(管道写端的引用计数大于0),而持有管道写
端的 进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数
据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/wait.h>
int main()
{
int _pipe_fd={-1,-1};//create pipe
if(pipe(_pipe_fd) < 0)
{
perror("pipe");
exit(1);
}
pid_t _pid=fork();//create init
if(_pid < 0)
{
perror("fork");
exit(2);
}
else if(_pid == 0)//Child
{
close(_pipe_fd);//close child read
int count=10;//child write
char buf[]="hello friends";
while(count)
{
if(count > 5)//write not close all
{
write(_pipe_fd,buf,strlen(buf));
}
sleep(1);
count--;
}
//close(_pipe_fd);//close child write
exit(0);//exit can return and close file by itself
}
else//Father
{
close(_pipe_fd);//close father write
char buf;//father read
while(1)
{
memset(buf,'\0',sizeof(buf));
ssize_t _size=read(_pipe_fd,buf,sizeof(buf)-1);
if(_size > 0)
{
buf='\0';
printf("%s\n",buf);
}
else if(_size == 0)
{
printf("Pipe is empty,child quit\n");
exit(3);
}
}
}
return 0;
} 运行结果：
（3）.如果所有指向管道读端的文件描述符都关闭了(管道读端的引用计数等于0),这时有进
程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/wait.h>
int main()
{
int _pipe_fd={-1,-1};//create pipe
if(pipe(_pipe_fd) < 0)
{
perror("pipe");
exit(1);
}
pid_t _pid=fork();//create init
if(_pid < 0)
{
perror("fork");
exit(2);
}
else if(_pid == 0)//Child
{
close(_pipe_fd);//close child read
int count=10;//child write
char buf[]="hello friends";
while(count--)
{
write(_pipe_fd,buf,strlen(buf));
sleep(1);
}
//close(_pipe_fd);//close child write
exit(0);//exit can return and close file by itself
}
else//Father
{
close(_pipe_fd);//close father write
char buf;//father read
while(1)
{
if(count==0)
{
close(_pipe_fd);//close father read
break;
}
memset(buf,'\0',sizeof(buf));
ssize_t _size=read(_pipe_fd,buf,sizeof(buf)-1);
if(_size > 0)
{
buf='\0';
printf("%s\n",buf);
}
else if(_size == 0)
{
printf("Pipe is empty,child quit\n");
exit(3);
}
}
int status=0;
if(waitpid(_pid,&status,0) == _pid)
{
printf("code; %s sig: %s\n",(status >> 8)& 0xFF,status & 0xFF);
}
}
return 0;
} 运行结果;
（4）.如果有指向管道读端的文件描述符没关闭(管道读端的引用计数大于0),而持有管道读
端的 进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时
再 次write会阻塞,直到管道中有空位置了才写入数据并返回。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/wait.h>
int main()
{
int _pipe_fd={-1,-1};//create pipe
if(pipe(_pipe_fd) < 0)
{
perror("pipe");
exit(1);
}
pid_t _pid=fork();//create init
if(_pid < 0)
{
perror("fork");
exit(2);
}
else if(_pid == 0)//Child
{
close(_pipe_fd);//close child read
int count=10;//child write
char buf[]="hello friends";
while(count--)
{
write(_pipe_fd,buf,strlen(buf));
sleep(1);
}
//close(_pipe_fd);//close child write
exit(0);//exit can return and close file by itself
}
else//Father
{
close(_pipe_fd);//close father write
char buf;//father read
while(1)
{
memset(buf,'\0',sizeof(buf));
ssize_t _size=read(_pipe_fd,buf,sizeof(buf)-1);
if(_size > 0)
{
buf='\0';
printf("%s\n",buf);
}
else if(_size == 0)
{
printf("Pipe is empty,child quit\n");
exit(3);
}
}
int status=0;
if(waitpid(_pid,&status,0) == _pid)
{
printf("code; %s sig: %s\n",(status >> 8)& 0xFF,status & 0xFF);
}
}
return 0;
} 运行结果：
页:
[1]