浅谈无缓存IO操作和标准IO文件操作区别.docx
《浅谈无缓存IO操作和标准IO文件操作区别.docx》由会员分享，可在线阅读，更多相关《浅谈无缓存IO操作和标准IO文件操作区别.docx（15页珍藏版）》请在冰豆网上搜索。
浅谈无缓存IO操作和标准IO文件操作区别
浅谈无缓存I/O操作和标准I/O文件操作区别
（2011-05-0211:
47:
57）
分类：
linux学习
首先，先稍微了解系统调用的概念：
系统调用，英文名systemcall，每个操作系统都在内核里有一些内建的函数库，这些函数可以用来完成一些系统系统调用把应用程序的请求传给内核，调用相应的的内核函数完成所需的处理，将处理结果返回给应用程序，如果没有系统调用和内核函数，用户将不能编写大型应用程序，及别的功能，这些函数集合起来就叫做程序接口或应用编程接口（ApplicationProgrammingInterface，API），我们要在这个系统上编写各种应用程序，就是通过这个API接口来调用系统内核里面的函数。
如果没有系统调用，那么应用程序就失去内核的支持。
现在，再聊不带缓存的I/O操作：
linix对IO文件的操作分为不带缓存的IO操作和标准IO操作（即带缓存），刚开始，要明确以下几点：
1：
不带缓存，不是直接对磁盘文件进行读取操作,像read（）和write（）函数，它们都属于系统调用，只不过在用户层没有缓存，所以叫做无缓存IO,但对于内核来说，还是进行了缓存，只是用户层看不到罢了。
如果这一点看不懂，请看第二点；
2：
带不带缓存是相对来说的，如果你要写入数据到文件上时（就是写入磁盘上），内核先将数据写入到内核中所设的缓冲储存器，假如这个缓冲储存器的长度是100个字节，你调用系统函：
ssize_twrite（intfd,constvoid*buf,size_tcount）;
写操作时，设每次写入长度count=10个字节，那么你几要调用10次这个函数才能把这个缓冲区写满，此时数据还是在缓冲区，并没有写入到磁盘，缓冲区满时才进行实际上的IO操作，把数据写入到磁盘上，所以上面说的“不带缓存不是就没有缓存直写进磁盘”就是这个意思。
那么，既然不带缓存的操作实际在内核是有缓存器的，那带缓存的IO操作又是怎么回事呢？
带缓存IO也叫标准IO，符合ANSIC的标准IO处理，不依赖系统内核，所以移植性强，我们使用标准IO操作很多时候是为了减少对read（）和write（）的系统调用次数，带缓存IO其实就是在用户层再建立一个缓存区，这个缓存区的分配和优化长度等细节都是标准IO库代你处理好了，不用去操心，还是用上面那个例子说明这个操作过程：
上面说要写数据到文件上，内核缓存（注意这个不是用户层缓存区）区长度是100字节，我们调用不带缓存的IO函数write（）就要调用10次，这样系统效率低，现在我们在用户层建立另一个缓存区（用户层缓存区或者叫流缓存），假设流缓存的长度是50字节，我们用标准C库函数的fwrite（）将数据写入到这个流缓存区里面，流缓存区满50字节后在进入内核缓存区，此时再调用系统函数write（）将数据写入到文件（实质是磁盘）上，看到这里，你用该明白一点，标准IO操作fwrite（）最后还是要掉用无缓存IO操作write,这里进行了两次调用fwrite（）写100字节也就是进行两次系统调用write（）。
如果看到这里还没有一点眉目的话，那就比较麻烦了，希望下面两条总结能够帮上忙：
无缓存IO操作数据流向路径：
数据——内核缓存区——磁盘
标准IO操作数据流向路径：
数据——流缓存区——内核缓存区——磁盘
下面是一个网友的见解，以供参考：
不带缓存的I/O对文件描述符操作，下面带缓存的I/O是针对流的。
标准I/O库就是带缓存的I/O，它由ANSIC标准说明。
当然，标准I/O最终都会调用上面的I/O例程。
标准I/O库代替用户处理很多细节，比如缓存分配、以优化长度执行I/O等。
标准I/O提供缓存的目的就是减少调用read和write的次数，它对每个I/O流自动进行缓存管理（标准I/O函数通常调用malloc来分配缓存）。
它提供了三种类型的缓存：
1）全缓存。
当填满标准I/O缓存后才执行I/O操作。
磁盘上的文件通常是全缓存的。
2）行缓存。
当输入输出遇到新行符或缓存满时，才由标准I/O库执行实际I/O操作。
stdin、stdout通常是行缓存的。
3）无缓存。
相当于read、write了。
stderr通常是无缓存的，因为它必须尽快输出。
一般而言，由系统选择缓存的长度，并自动分配。
标准I/O库在关闭流的时候自动释放缓存。
在标准I/O库中，一个效率不高的不足之处是需要复制的数据量。
当使用每次一行函数fgets和fputs时，通常需要复制两次数据：
一次是在内核和标准I/O缓存之间（当调用read和write时），第二次是在标准I/O缓存（通常系统分配和管理）和用户程序中的行缓存（fgets的参数就需要一个用户行缓存指针）之间。
不管上面讲的到底懂没懂，记住一点：
使用标准I/O例程的一个优点是无需考虑缓存及最佳I/O长度的选择，并且它并不比直接调用read、write慢多少。
带缓存的文件操作是标准C库的实现，第一次调用带缓存的文件操作函数时标准库会自动分配内存并且读出一段固定大小的内容存储在缓存中。
所以以后每次的读写操作并不是针对硬盘上的文件直接进行的，而是针对内存中的缓存的。
何时从硬盘中读取文件或者向硬盘中写入文件有标准库的机制控制。
不带缓存的文件操作通常都是系统提供的系统调用，更加低级，直接从硬盘中读取和写入文件，由于IO瓶颈的原因，速度并不如意，而且原子操作需要程序员自己保证，但使用得当的话效率并不差。
另外标准库中的带缓存文件IO是调用系统提供的不带缓存IO实现的。
这里为了说明标准I/O的工作原理,借用了glibc中标准I/O实现的细节,所以代码多是不可移植的.
1.bufferedI/O,即标准I/O
首先,要明确,unbufferedI/O只是相对于bufferedI/O,即标准I/O来说的.
而不是说unbufferedI/O读写磁盘时不用缓冲.实际上,内核是存在高速缓冲区来进行
真正的磁盘读写的,不过这里要讨论的buffer跟内核中的缓冲区无关.
bufferedI/O的目的是什么呢?
很简单,bufferedI/O的目的就是为了提高效率.
请明确一个关系,那就是,
bufferedI/O库函数（fread,fwrite等,用户空间）<----call---> unbufferedI/O系统调用（read,write等,内核空间）<------->读写磁盘
bufferedI/O库函数都是调用相关的unbufferedI/O系统调用来实现的,他们并不直接读写磁盘.
那么,效率的提高从何而来呢?
注意到,bufferedI/O中都是库函数,而unbufferedI/O中为系统调用,使用库函数的效率是高于使用系统调用的.
bufferedI/O就是通过尽可能的少使用系统调用来提高效率的.
它的基本方法是,在用户进程空间维护一块缓冲区,第一次读（库函数）的时候用read（系统调用）多从内核读出一些数据,
下次在要读（库函数）数据的时候,先从该缓冲区读,而不用进行再次read（系统调用）了.
同样,写的时候,先将数据写入（库函数）一个缓冲区,多次以后,在集中进行一次write（系统调用）,写入内核空间.
bufferedI/O中的fgets,puts,fread,fwrite等和unbufferedI/O中的read,write等就是调用和被调用的关系
下面是一个利用bufferedI/O读取数据的例子:
#include
#include
#include
#include
#include
int main（void）
{
char buf[5];
FILE *myfile = stdin;
fgets（buf, 5, myfile）;
fputs（buf, myfile）;
return 0;
}
bufferedI/O中的"buffer"到底是指什么呢?
这个buffer在什么地方呢?
FILE是什么呢?
它的空间是怎么分配的呢?
要弄清楚这些问题,就要看看FILE是如何定义和运作的了.
（特别说明,在平时写程序时,不用也不要关心FILE是如何定义和运作的,最好不要直接操作
它,这里使用它,只是为了说明bufferedIO）
下面的这个是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都指向了同一个缓冲区.
这个缓冲区跟上面程序中的charbuf[5];没有任何关系.
他们在第一次bufferedI/O操作时由库函数自动申请空间,最后由相应库函数负责释放.
（再次声明,这里只是glibc的实现,别的实现可能会不同,后面就不再强调了）
请看下面的程序（这里给的是stdin,行缓冲的例子）:
#include
#include
#include
#include
#include
int main（void）
{
char buf[5];
FILE *myfile =stdin;
printf（"beforereading\n"）;
printf（"readbufferbase%p\n", myfile->_IO_read_base）;
printf（"readbufferlength%d\n", myfile->_IO_read_end - myfile->_IO_read_base）;
printf（"writebufferbase%p\n", myfile->_IO_write_base）;
printf（"writebufferlength%d\n", myfile->_IO_write_end - myfile->_IO_write_base）;
printf（"bufbufferbase%p\n", myfile->_IO_buf_base）;
printf（"bufbufferlength%d\n", myfile->_IO_buf_end - myfile->_IO_buf_base）;
printf（"\n"）;
fgets（buf, 5, myfile）;
fputs（buf, myfile）;
printf（"\n"）;
printf（"afterreading\n"）;
printf（"readbufferbase%p\n", myfile->_IO_read_base）;
printf（"readbufferlength%d\n", myfile->_IO_read_end - myfile->_IO_read_base）;
printf（"writebufferbase%p\n", myfile->_IO_write_base）;
printf（"writebufferlength%d\n", myfile->_IO_write_end - myfile->_IO_write_base）;
printf（"bufbufferbase%p\n", myfile->_IO_buf_base）;
printf（"bufbufferlength%d\n", myfile->_IO_buf_end - myfile->_IO_buf_base）;
return 0;
}
可以看到,在读操作之前,myfile的缓冲区是没有被分配的,在一次读之后,myfile的缓冲区才被分配.
这个缓冲区既不是内核中的缓冲区,也不是用户分配的缓冲区,而是有用户进程空间中的由bufferedI/O系统负责维护的缓冲区.
用setbuf设置stdin缓冲区大小后（printf（"bufbufferlength%d\n", myfile->_IO_buf_end - myfile->_IO_buf_base）;）默认是8192，但是只能读setbuf设置的大小，也就是：
printf（"readbufferlength%d\n", myfile->_IO_read_end - myfile->_IO_read_base）;如果越界程序将执行错误
（当然,用户可以可以维护该缓冲区,这里不做讨论了）
上面的例子只是说明了bufferedI/O缓冲区的存在,下面从全缓冲,行缓冲和无缓冲3个方面看一下bufferedI/O
是如何工作的.
1.1.全缓冲
下面是APUE上的原话:
全缓冲"在填满标准I/O缓冲区后才进行实际的I/O操作.对于驻留在磁盘上的文件通常是由标准I/O库实施全缓冲的"
书中这里"实际的I/O操作"实际上容易引起误导,这里并不是读写磁盘,而应该是进行read或write的系统调用
下面两个例子会说明这个问题
#include
#include
#include
#include
#include
int main（void）
{
char buf[5];
char *cur;
FILE *myfile;
myfile = fopen（"bbb.txt", "r"）;
printf（"beforereading,myfile->_IO_read_ptr:
%d\n", myfile->_IO_read_ptr -myfile->_IO_read_base）;
fgets（buf, 5, myfile）; //仅仅读4个字符
cur = myfile->_IO_read_base;
while （cur < myfile->_IO_read_end） //实际上读满了这个缓冲区
{
printf（"%c",*cur）;
cur++;
}
printf（"\nafterreading,myfile->_IO_read_ptr:
%d\n", myfile->_IO_read_ptr -myfile->_IO_read_base）;
return 0;
}
上面提到的bbb.txt文件的内容是由很多行的"123456789"组成
上例中,fgets（buf,5,myfile）;仅仅读4个字符,但是,缓冲区已被写满,（这个缓冲区默认是4096）
但是_IO_read_ptr却向前移动了5位,下次再次调用读操作时,
只要要读的位数不超过myfile->_IO_read_end-myfile->_IO_read_ptr
那么就不需要再次调用系统调用read,只要将数据从myfile的缓冲区拷贝到
buf即可（从myfile->_IO_read_ptr开始拷贝）
全缓冲读的时候,
_IO_read_base始终指向缓冲区的开始
_IO_read_end始终指向已从内核读入缓冲区的字符的下一个
（对全缓冲来说,bufferedI/O读每次都试图都将缓冲区读满）
_IO_read_ptr始终指向缓冲区中已被用户读走的字符的下一个
（_IO_read_end<（_IO_buf_base-_IO_buf_end））&&（_IO_read_ptr==_IO_read_end）时则已经到达文件末尾
其中_IO_buf_base-_IO_buf_end是缓冲区的长度
一般大体的工作情景为:
第一次fgets（或其他的）时,标准I/O会调用read将缓冲区充满,下一次fgets不调用read而是直接从该缓冲区中拷贝数据,直到
缓冲区的中剩余的数据不够时,再次调用read.在这个过程中,_IO_read_ptr就是用来记录缓冲区中哪些数据是已读的,
哪些数据是未读的.
#include
#include
#include
#include
#include
int main（void）
{
char buf[2048]={0};
int i;
FILE *myfile;
myfile = fopen（"aaa.txt", "r+"）;
i= 0;
while （i<2048）
{
fwrite（buf+i, 1, 512, myfile）;
i +=512;
//注释掉这句则可以写入aaa.txt
myfile->_IO_write_ptr = myfile->_IO_write_base;
printf（"%pwritebufferbase\n", myfile->_IO_write_base）;
printf（"%pbufbufferbase\n", myfile->_IO_buf_base）;
printf（"%preadbufferbase\n", myfile->_IO_read_base）;
printf（"%pwritebufferptr\n", myfile->_IO_write_ptr）;
printf（"\n"）;
}
return 0;
}
上面这个是关于全缓冲写的例子.
全缓冲时,只有当标准I/O自动flush（比如当缓冲区已满时）或者手工调用fflush时,
标准I/O才会调用一次write系统调用.
例子中,fwrite（buf+i,1,512,myfile）;这一句只是将buf+i接下来的512个字节
写入缓冲区,由于缓冲区未满,标准I/O并未调用write.
此时,myfile->_IO_write_ptr=myfile->_IO_write_base;会导致标准I/O认为
没有数据写入缓冲区,所以永远不会调用write,这样aaa.txt文件得不到写入.
注释掉myfile->_IO_write_ptr=myfile->_IO_write_base;前后,看看效果
全缓冲写的时候:
_IO_write_base始终指向缓冲区的开始
_IO_write_end全缓冲的时候,始终指向缓冲区的最后一个字符的下一个
（对全缓冲来说,bufferedI/O写总是试图在缓冲区写满之后,再系统调用write）
_IO_write_ptr始终指向缓冲区中已被用户写入的字符的下一个
flush的时候,将_IO_write_base和_IO_write_ptr之间的字符通过系统调用write写入内核
1.2.行缓冲
下面是APUE上的原话:
行缓冲"当输入输出中遇到换行符时,标准I/O库执行I/O操作."
书中这里"执行O操作"也容易引起误导,这里不是读写磁盘,而应该是进行read或write的系统调用
下面两个例子会说明这个问题
第一个例子可以用来说明下面这篇帖子的问题
#include
#include
int main（void）
{
char buf[5];
char buf2[10];
fgets（buf, 5, stdin）; //第一次输入时,超过5个字符
puts（stdin->_IO_read_ptr）;//本句说明整行会被一次全部读入缓冲区,
//而非仅仅上面需要的个字符
stdin->_IO_read_ptr = stdin->_IO_read_end; //标准I/O会认为缓冲区已空,再次调用read
//注释掉,再看看效果
printf（"\n"）;
puts（buf）;
fgets（buf2, 10, stdin）;
puts（buf2）;
return 0;
}
上例中,fgets（buf,5,stdin）;仅仅需要4个字符,但是,输入行中的其他数据也被写入
升级会员 