管道的内核实现
一.概述:
创新互联专注于尧都企业网站建设,成都响应式网站建设公司,成都商城网站开发。尧都网站建设公司,为尧都等地区提供建站服务。全流程定制网站,专业设计,全程项目跟踪,创新互联专业和态度为您提供的服务
管道是进程间通信的手段之一,它实际上是一个存在于内存的特殊文件,而这个文件要通过两个已经打开的文件才能进行操作,这两个文件分别指向管道的两端。
管道是通过在内存中开辟一个缓存区来实现进程间的通信的,这个缓存区的大小是固定的。在linux中,这个缓存区的大小为一页,即4k。但固定的大小会带来问题,当缓存区已经被write操作写满时,之后的write操作会阻塞,等待缓存区内的某些数据被读取,以便腾出空间给写操作调用。
在linux中,管道并没有专门的数据结构,而是通过file结构和inode共同实现。两个file结构指向一个inode,而这个inode对应了内存的某个区域。
注:一个file中的f_op只对应写或者读操作中的一个。
而管道创建的缓存区是一个环形缓存区,即当用到缓存区的尾部时,下一个可用区间为缓存区的首部。缓存区一般采用的是数组形式,即申请的是一个线性的地址空间。而形成环状用的是 模 缓存区长度。而访问这个缓存区的方式是一种典型的“生产者—消费者模型”,即当生产者有大量的数据要写时,而缓存区的大小只有1k,所以当缓存区被写满时,生产者必须等待,等待消费者读取数据,以便腾出空间让消费者写。而当消费者发现缓存区内并没有数据时,消费者必须等待,等待生产者往缓存区内写数据来提供消费者读数据。
那么又如何判断是“空”还是“满”呢。当read和write指向环形缓存区的同一位置时为空或满。为了区别空和满,规定read和write重叠时为空,而当write比read快,追到距离read还有一个元素间隔时,就认为是满。
摘:(不明觉厉)
并发访问
考虑到在不同环境下,任务可能对环形缓冲区的访问情况不同,需要对并发访问的情况进行分析。
在单任务环境下,只存在一个读任务和一个写任务,只要保证写任务可以顺利的完成将数据写入,而读任务可以及时的将数据读出即可。如果有竞争发生,可能会出现如下情况:
Case1:假如写任务在“写指针加1,指向下一个可写空位置”执行完成时被打断,此时写指针write指向非法位置。当系统调度读任 务执行时,如果读任务需要读多个数据,那么不但应该读出的数据被读出,而且当读指针被调整为0是,会将以前已经读出的数据重复读出。
Case2:假设读任务进行读操作,在“读指针加1”执行完时被打断,此时read所处的位置是非法的。当系统调度写任务执行时,如果 写任务要写多个数据,那么当写指针指到尾部时,本来缓冲区应该为满状态,不能再写,但是由于读指针处于非法位置,在读任务执行前,写任务会任务缓冲区为 空,继续进行写操作,将覆盖还没有来的及读出的数据。
二.用管道实现进程间的通信:
代码:
#include
#include
#include
#include
#include
int main()
{
//.....创建管道
int pipefd[2] ={-1,-1};
int ret = pipe(pipefd);
if(ret == -1)
{
perror("pipe");
return -1;
}
//....创建子进程
pid_t id = fork();
if(id < 0)
{
perror("fork");
return -1;
}
else if(id == 0)
{
//....子进程关闭读端
close(pipefd[0]);
char* buf = "i'm child";
int count = 5;
while(count--)
{
write(pipefd[1],buf,strlen(buf));
sleep(1);
}
}
else
{
//....父进程关闭写端
close(pipefd[1]);
char buf[1024];
int count = 5;
while(count--)
{
memset(buf, '\0', sizeof(buf));
ssize_t size = read(pipefd[0],buf,sizeof(buf) - 1);
buf[size] = '\0';
printf("%s\n",buf);
}
}
}
结果截图:
三.使用管道会出现的四种情况(假设都是阻塞I/O操作,没有设置O_NONBLOCK标志):
1:当所有写端都关闭时,但还有进程要从管道中读取数据,那么当管道中的数据读完后,再次read时,就会返回0,就像读到文件末尾一样。
代码如下:
#include
#include
#include
#include
#include
int main()
{
//.....创建管道
int pipefd[2] ={-1,-1};
int ret = pipe(pipefd);
if(ret == -1)
{
perror("pipe");
return -1;
}
//....创建子进程
pid_t id = fork();
if(id < 0)
{
perror("fork");
return -1;
}
else if(id == 0)
{
//....子进程关闭写端
close(pipefd[1]);
char buf[1024];
int count = 5;
while(count--)
{
memset(buf, '\0', sizeof(buf));
ssize_t size = read(pipefd[0],buf,sizeof(buf) - 1);
if(size > 0)
{
buf[size] = '\0';
printf("%s\n",buf);
}
else
{
printf("read error");
}
}
}
else
{
//....父进程关闭读端
close(pipefd[0]);
char* buf = "i'm father";
int count = 5;
int i = 0;
while(count--)
{
if(i == 3)
{
printf("i just want to sleep");
break;
}
i++;
write(pipefd[1],buf,strlen(buf));
sleep(1);
}
}
}
执行结果:
2.如果指向管道写端的文件标识符没关闭,但写端也不向管道中写数据时,如果此时有进程从管道中读数据,那么当缓存区内的数据被读完之后,再次read,读进程会进入阻塞状态,直到缓存区内有数据才进行读数据。
代码如下:
#include
#include
#include
#include
#include
int main()
{
//.....创建管道
int pipefd[2] ={-1,-1};
int ret = pipe(pipefd);
if(ret == -1)
{
perror("pipe");
return -1;
}
//....创建子进程
pid_t id = fork();
if(id < 0)
{
perror("fork");
return -1;
}
else if(id == 0)
{
//....子进程关闭写端
close(pipefd[1]);
char buf[1024];
int count = 5;
while(count--)
{
memset(buf, '\0', sizeof(buf));
ssize_t size = read(pipefd[0],buf,sizeof(buf) - 1);
if(size > 0)
{
buf[size] = '\0';
printf("%s\n",buf);
}
}
}
else
{
//....父进程关闭读端
close(pipefd[0]);
char* buf = "i'm father";
int count = 5;
int i = 0;
while(count--)
{
if(i == 3)
{
printf("i just want to sleep\n");
sleep(5);
}
i++;
write(pipefd[1],buf,strlen(buf));
sleep(1);
}
}
}
执行结果:
3.如果所有指向管道的读端都关闭了,但还有进程要往管道中写数据,那么进程就会收到信号SIGPIPE,通常会导致进程异常终止。(因为此时再写也没用,又没进程要读)
代码如下:
#include
#include
#include
#include
#include
int main()
{
//.....创建管道
int pipefd[2] ={-1,-1};
int ret = pipe(pipefd);
if(ret == -1)
{
perror("pipe");
return -1;
}
//....创建子进程
pid_t id = fork();
if(id < 0)
{
perror("fork");
return -1;
}
else if(id == 0)
{
//....子进程关闭读端
close(pipefd[0]);
char buf[] = "i'm child";
int count = 5;
while(count--)
{
write(pipefd[1],buf,strlen(buf));
sleep(1);
}
}
else
{
//....父进程关闭写端
close(pipefd[1]);
char buf[1024];
int count = 5;
int i = 0;
while(count--)
{
if(i == 3)
{
close(pipefd[0]);
break;
}
i++;
int ret = 0;
memset(buf, '\0', sizeof(buf));
ret = read(pipefd[0],buf,sizeof(buf) - 1);
buf[ret] = '\0';
if(ret > 0)
{
printf("%s\n",buf);
fflush(stdout);
}
}
int status = 0;
pid_t pid = waitpid(id, &status, 0);
printf("pid: [%d] signal:[%d]\n",id,status|0xff);
fflush(stdout);
}
}
执行结果:
4.如果指向管道读端的文件标识符没有关闭,但又不读缓存区内的内容,那么如果此时还有进程要往缓存区内写,而缓存区已被写满时,写进程会阻塞,直到缓存区内有空位置之后才能写。
代码如下:
#include
#include
#include
#include
#include
int main()
{
//.....创建管道
int pipefd[2] ={-1,-1};
int ret = pipe(pipefd);
if(ret == -1)
{
perror("pipe");
return -1;
}
//....创建子进程
pid_t id = fork();
if(id < 0)
{
perror("fork");
return -1;
}
else if(id == 0)
{
//....子进程关闭读端
close(pipefd[0]);
char buf[] = "i'm child";
int count = 5;
while(count--)
{
write(pipefd[1],buf,strlen(buf));
sleep(1);
}
}
else
{
//....父进程关闭写端
close(pipefd[1]);
char buf[1024];
int count = 5;
int i = 0;
while(count--)
{
if(i == 3)
{
printf("i just want to sleep\n");
fflush(stdout);
sleep(5);
}
i++;
int ret = 0;
memset(buf, '\0', sizeof(buf));
ret = read(pipefd[0],buf,sizeof(buf) - 1);
buf[ret] = '\0';
if(ret > 0)
{
printf("%s\n",buf);
fflush(stdout);
}
}
int status = 0;
pid_t pid = waitpid(id, &status, 0);
printf("pid: [%d] signal:[%d]\n",id,status|0xff);
fflush(stdout);
}
}
执行结果:
网页题目:管道的内核实现
文章分享:http://myzitong.com/article/pijidh.html