本文详细解析了Linux系统中文件操作的缓存机制，包括无缓存和带缓存两种模式的区别，以及fsync和fflush函数的作用。通过具体实例展示了全缓冲读写过程中的内部工作原理。
能找到的最"源头"的原文地址了：http://blog.sina.com.cn/s/blog_6592a07a0101gar7.html
文章很不错，但没有图片，代码也不能直接用，所以自己做了修改
-----------------------------------------------------------
一、IO缓存
系统调用：只操作系统提供给用户程序调用的一组接口-------获得内核提供的服务。
- 不带缓存：open read。posix标准，在用户空间没有缓冲，在内核空间还是进行了缓存的。数据-----内核缓存区----磁盘。假设内核缓存区长度为100字节，你调用ssize_t write (int fd,const void * buf,size_t count);写操作时，设每次写入count=10字节，那么你要调用10次这个函数才能把这个缓存区写满，没写满时数据还是在内核缓冲区中，并没有写入到磁盘中，内核缓存区满了之后或者执行了fsync（强制写入硬盘）之后，才进行实际的IO操作，吧数据写入磁盘上。
- 带缓存区：fopen fwrite fget 等，是c标准库中定义的。数据-----流缓存区-----内核缓存区----磁盘。假设流缓存区长度为50字节，内核缓存区100字节，我们用标准c库函数fwrite()将数据写入到这个流缓存中，每次写10字节，需要写5次流缓存区满后调用write()(或调用fflush())，将数据写到内核缓存区，直到内核缓存区满了之后或者执行了fsync（强制写入硬盘）之后，才进行实际的IO操作，吧数据写入磁盘上。标准IO操作fwrite()最后还是要掉用无缓存IO操作write。
以fgetc / fputc 为例,当用户程序第一次调用fgetc 读一个字节时,fgetc 函数可能通过系统调用 进入内核读1K字节到I/O缓冲区中,然后返回I/O缓冲区中的第一个字节给用户,把读写位置指 向I/O缓冲区中的第二个字符,以后用户再调fgetc ,就直接从I/O缓冲区中读取,而不需要进内核 了,当用户把这1K字节都读完之后,再次调用fgetc 时,fgetc 函数会再次进入内核读1K字节 到I/O缓冲区中。在这个场景中用户程序、C标准库和内核之间的关系就像在“Memory Hierarchy”中 CPU、Cache和内存之间的关系一样,C标准库之所以会从内核预读一些数据放 在I/O缓冲区中,是希望用户程序随后要用到这些数据,C标准库的I/O缓冲区也在用户空间,直接 从用户空间读取数据比进内核读数据要快得多。另一方面,用户程序调用fputc 通常只是写到I/O缓 冲区中,这样fputc 函数可以很快地返回,如果I/O缓冲区写满了,fputc 就通过系统调用把I/O缓冲 区中的数据传给内核,内核最终把数据写回磁盘或设备。有时候用户程序希望把I/O缓冲区中的数据立刻 传给内核,让内核写回设备或磁盘,这称为Flush操作,对应的库函数是fflush,fclose函数在关闭文件 之前也会做Flush操作。
虽然write 系统调用位于C标准库I/O缓冲区的底 层,被称为Unbuffered I/O函数,但在write 的底层也可以分配一个内核I/O缓冲区,所以write 也不一定是直接写到文件的,也 可能写到内核I/O缓冲区中,可以使用fsync函数同步至磁盘文件，至于究竟写到了文件中还是内核缓冲区中对于进程来说是没有差别 的,如果进程A和进程B打开同一文件,进程A写到内核I/O缓冲区中的数据从进程B也能读到,因为内核空间是进程共享的, 而c标准库的I/O缓冲区则不具有这一特性,因为进程的用户空间是完全独立的.
buffered I/O中的"buffer"到底是指什么呢?这个buffer在什么地方呢?FILE是什么呢?它的空间是怎么分配的呢 要弄清楚这些问题,就要看看FILE是如何定义和运作的了.(特别说明,在平时写程序时,不用也不要关心FILE是如何定义和运作的,最好不要直接操作它,这里使用它,只是为了说明buffered IO)下面的这个是glibc给出的FILE的定义,它是实现相关的,别的平台定义方式不同.
struct _IO_FILE { int _flags; #define _IO_file_flags _flags char* _IO_read_ptr; char* _IO_read_end; char* _IO_read_base; char* _IO_write_base; char* _IO_write_ptr; char* _IO_write_end; char* _IO_buf_base; char* _IO_buf_end; char *_IO_save_base; char *_IO_backup_base; char *_IO_save_end; struct _IO_marker *_markers; struct _IO_FILE *_chain; int _fileno; };
上面的定义中有三组重要的字段:
1. char* _IO_read_ptr; char* _IO_read_end; char* _IO_read_base; 2. char* _IO_write_base; char* _IO_write_ptr; char* _IO_write_end; 3. char* _IO_buf_base; char* _IO_buf_end;
_IO_read_base 指向"读缓冲区"
_IO_read_end 指向"读缓冲区"的末尾
_IO_read_end - _IO_read_base "读缓冲区"的长度
_IO_write_base 指向"写缓冲区"
_IO_write_end 指向"写缓冲区"的末尾
_IO_write_end - _IO_write_base "写缓冲区"的长度
_IO_buf_base 指向"缓冲区"
_IO_buf_end 指向"缓冲区"的末尾
_IO_buf_end - _IO_buf_base "缓冲区"的长度
上面的定义貌似给出了3个缓冲区,实际上上面的_IO_read_base,_IO_write_base, _IO_buf_base都指向了同一个缓冲区.这个缓冲区跟上面程序中的char buf[5];没有任何关系.他们在第一次buffered I/O操作时由库函数自动申请空间,最后由相应库函数负责释放.(再次声明,这里只是glibc的实现,别的实现可能会不同,后面就不再强调了)
请看下面的程序(这里给的是stdin,行缓冲的例子):
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
char buf[5];
FILE *myfile =stdin;
printf("before reading\n");
printf("read buffer base %p\n", myfile->_IO_read_base);
printf("read buffer length %d\n", myfile->_IO_read_end - myfile->_IO_read_base);
printf("write buffer base %p\n", myfile->_IO_write_base);
printf("write buffer length %d\n", myfile->_IO_write_end - myfile->_IO_write_base);
printf("buf buffer base %p\n", myfile->_IO_buf_base);
printf("buf buffer length %d\n", myfile->_IO_buf_end - myfile->_IO_buf_base);
printf("\n");
fgets(buf, 5, myfile);
fputs(buf, myfile);
printf("\n");
printf("after reading\n");
printf("read buffer base %p\n", myfile->_IO_read_base);
printf("read buffer length %d\n", myfile->_IO_read_end - myfile->_IO_read_base);
printf("write buffer base %p\n", myfile->_IO_write_base);
printf("write buffer length %d\n", myfile->_IO_write_end - myfile->_IO_write_base);
printf("buf buffer base %p\n", myfile->_IO_buf_base);
printf("buf buffer length %d\n", myfile->_IO_buf_end - myfile->_IO_buf_base);
return 0;
}
可以看到,在读操作之前,myfile的缓冲区是没有被分配的,在一次读之后,myfile的缓冲区才被分配.这个缓冲区既不是内核中的缓冲区,也不是用户分配的缓冲区,而是有用户进程空间中的由buffered I/O系统负责维护的缓冲区.(当然,用户可以可以维护该缓冲区,这里不做讨论了) 上面的例子只是说明了buffered I/O缓冲区的存在,下面从全缓冲,行缓冲和无缓冲3个方面看一下buffered I/O是如何工作的.
二、 全缓冲
下面是APUE上的原话:全缓冲"在填满标准I/O缓冲区后才进行实际的I/O操作.对于驻留在磁盘上的文件通常是由标准I/O库实施全缓冲的"书中这里"实际的I/O操作"实际上容易引起误导,这里并不是读写磁盘,而应该是进行read或write的系统调用,下面两个例子会说明这个问题:
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
char buf[5];
char *cur;
FILE *myfile=NULL;
myfile = fopen("./bbb.txt", "r");
if(!myfile)
puts("open err!");
printf("before reading, myfile->_IO_read_ptr: %d\n", myfile->_IO_read_ptr - myfile->_IO_read_base);
fgets(buf, 5, myfile); //仅仅读4个字符
cur = myfile->_IO_read_base;
printf("%p-%p\n",myfile->_IO_read_base,myfile->_IO_read_end);
printf("buffer:%s\n",myfile->_IO_read_base);
while (cur > myfile->_IO_read_end) //实际上读满了这个缓冲区
{
printf("%c",*cur);
cur++;
}
printf("/nafter reading, myfile->_IO_read_ptr: %d\n", myfile->_IO_read_ptr - myfile->_IO_read_base);
return 0;
}
上面提到的bbb.txt文件的内容是由很多行的"123456789"组成上例中,fgets(buf, 5, myfile); 仅仅读4个字符,但是,缓冲区已被写满,但是_IO_read_ptr却向前移动了5位,下次再次调用读操作时,只要要读的位数不超过myfile->_IO_read_end - myfile->_IO_read_ptr那么就不需要再次调用系统调用read,只要将数据从myfile的缓冲区拷贝到buf即可(从myfile->_IO_read_ptr开始拷贝)
一般大体的工作情景为:第一次fgets(或其他的)时,标准I/O会调用read将缓冲区充满,下一次fgets不调用read而是直接从该缓冲区中拷贝数据,直到缓冲区的中剩余的数据不够时,再次调用read.在这个过程中,_IO_read_ptr就是用来记录缓冲区中哪些数据是已读的,
哪些数据是未读的.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
char buf[2048]={"sssssssssssssssssssss \
ssssssssssssssssssssssssssssssssssssss"};
int i;
FILE *myfile=NULL;
fflush(stdout);
myfile = fopen("aa.txt", "a+");
if(!myfile)
puts("open err!");
fwrite(buf, 1, 10, myfile);
//注释掉这句则可以写入aaa.txt
//myfile->_IO_write_ptr = myfile->_IO_write_base;
printf("%p write buffer base\n", myfile->_IO_write_base);
printf("%p buf buffer base \n", myfile->_IO_buf_base);
printf("%p read buffer base \n", myfile->_IO_read_base);
printf("%p write buffer ptr \n", myfile->_IO_write_ptr);
printf("\n");
puts("--------------------------");
printf("buffer:%s\n",myfile->_IO_write_base);
int fd=fileno(myfile);
char sBuf[256]={0};
read(fd,sBuf,sizeof(sBuf));
write(1,sBuf,strlen(sBuf));
return 0;
}
扫一扫
1239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
