linux基础IO——用户缓冲区——概念深度探索、IO模拟实现

2025-05-02 22:37:46 0 阅读

前言：本篇文章主要讲解文件缓冲区。讲解的方式是通过抛出问题，然后通过分析问题，将缓冲区的概念与原理一步一步地讲解。同时，本节内容在最后一部分还会带友友们模拟实现一下c语言的printf， fprintf接口，加深友友们对于缓冲区的理解。

ps：本节内容适合了解linux进程和linux文件重定向的友友们进行观看。

缓冲区概念——使用close引出

exit和用户缓冲区

缓冲区刷新方案

为什么要有用户缓冲区

FILE

fork和缓冲区读写

模拟实现c语言标准库

只包含fd的接口——不带缓冲区

c语言的跨平台性

带缓冲区的c语言接口

fflush

缓冲区概念——使用close引出

讲述缓冲区，我们需要先看一下下面的接口：

对于上面的接口，我们可以预测一下——就是打印4行内容，分别是hello printf、hello fprintf、hello fwrite、hello write：

如图，代码运行结果符合我们的预期。对于上面的代码我们知道，对于c语言的接口， stdoutFILE文件流里面就封装了1号文件描述符。他们的底层一定是调用了write函数。

对于上面的函数，我们重定向到文件是这样，和直接在显示器上面输出是一样的。

但是，如果加上close（1），将显示器文件关闭，那么情况就有些不同了，下面是有的:

下面是没有的：

如果没有了，对于c语言的打印接口，就不能输出了。

如下图，只输出了系统调用write:

我们知道对于上面printf、fprintf、fwrite来说，这三个是c语言接口，他们的底层一定是封装的write接口。这就有问题了， 为什么printf、fprintf、fwrite的底层是write，而write能够打印数据， printf、fprintf、fwrite都不能打印数据呢？

友友们如果学习过进度条，那么就会知道一个缓冲区的概念。这个缓冲区遇到或者缓冲区满了之后就会刷新自己。

一般情况下，我们使用printf、fprintf、fwrite不是直接写向显示器，而是先写向缓冲区。等到遇到或者缓冲区满了之后再刷新缓冲区，将数据刷新到缓冲区。

也就是说，对于上面的这个代码来说，当程序运行到close(1)前一行， 那么数据就已经写到缓冲区了。只是这个缓冲区一定不在操作系统内部，这个缓冲区不是系统级别的缓冲区！！！

具体的底层逻辑关系如下:

我们使用的c语言接口的时候，如果是将数据直接拷贝到了系统级别的缓冲区中，那么等到close(1)的时候，这个close（1）就能找到对应的文件struct file，然后找到对应的系统级别的文件缓冲区，将缓冲区内容刷新到磁盘里面。也就是说，如果c语言接口是将数据只拷贝到系统级别的缓冲区，那么我们应该也能看到c语言接口的结果，而事实上并没有。而write是系统调用接口，是直接写到系统级别的文件缓冲区，那么当close（1）的时候，就能直接将数据刷新到磁盘里面。

我们平时口中的缓冲区，不是这个系统级别的缓冲区，而是语言提供的，这里也就是c语言提供的一个缓冲区，这个缓冲区是一个用户级别的缓冲区。也就是说， c语言的printf， fprintf等接口是将数据写到语言级别的缓冲区中，然后等到某一个时机就调用write接口，将数据刷新到系统级别的缓冲区中，最后再刷新到磁盘中。

所以，当我们printf、fprintf等等的时候，这些数据其实是保存在语言级别的缓冲区，他们还没有进入系统级别的缓冲区，当close（1）的时候。1号文件struct file，系统文件缓冲区都被关掉了。就无法再向磁盘写入数据了，也就没有显示结果。

显示器对应的刷新方案是行刷新，当我们在c语言接口要打印的数据中加上的时候，如下图，那么即便有close(1)，但是对于用户缓冲区来说，每一行都会被刷新到系统级别的文件缓冲区。所以可以打印出来。用户缓冲区刷新的本质就是将数据通过1 + write写到内核中。

exit和用户缓冲区

我们之前说过exit和_exit， exit是封装的上层接口，而_exit是系统调用。两者的区别是_exit退出前不会刷新缓冲区（我们口中的缓冲区，都是用户级缓冲区），而exit会刷新缓冲区（我们口中的缓冲区，都是用户级缓冲区）。这是因为_exit身为系统调用，它在用户层的下层，它根本看不到用户级缓冲区。也就没办法刷新它，而exit处在用户层，它底层一定是先刷新缓冲区flush，然后再调用系统调用_exit。

从上面我的论述中就可以发现，其实当数据到达内核的时候，那么这个数据就可以到达硬件了。 ——这也是我们目前认为的，只要是将数据刷新到了内核，数据就可以到达硬件了！！！

缓冲区刷新方案

缓冲区刷新问题：——这里的缓冲区考虑的是语言层，也就是用户层缓冲区。

无缓冲：直接刷新，不管printf， fprintf等接口打印的数据是什么，直接刷新。
行缓冲：不刷新，直到遇到再刷新。
全缓冲：缓冲区满了再刷新，不满的话，无论如何都不刷新。

所以整个的刷新流程如下图:

在向显示器中写入的时候，采用的是行缓冲。

在向普通文件中写入的时候，采用的是全缓冲。

为什么要有用户缓冲区

进程退出的时候也会刷新缓冲区，为什么要有这个缓冲区呢？

首先就是效率层面——这里可以使用一个例子来说明这件事，就比如我们给朋友送东西，如果没有快递公司，我们就必须亲自去送东西给朋友，但是现在有了快递公司，快递公司就可以帮助我们去送快递，我们节省的这些时间就可以去做自己的事情。——这里面的快递公司就是缓冲区，我们就是用户。所以，缓冲区解决的是谁的效率问题？——其实就是用户的效率问题。（也就是使用c语言的人的效率问题）

其次是语言设计层面——拥有缓冲区的目的是为了配合c语言接口：printf，fprintf的输出格式化。——这里我们需要想一个问题，就是我们在显示器上面打印的789，这样的数字，打印的是字符呢？打印的还是数字呢？ ——答案是打印的字符789。也就是说，将789转化成字符7，字符8，字符9，然后再打印到显示器上面。当数据打印的时候，先将数据打印到用户缓冲区。当某个时机的时候，就将用户缓冲区的数据打印到硬件里面。由于这种数据进入，数据流出，很像一条河流，所以用户缓冲区也被叫做流。

FILE

请问， FILE是属于用户呢？还是属于操作系统呢？答案是用户，语言都是属于用户的。

知道这个之后，我们就可以知道，对于fopen来说

如果使用fopen打开了一个文件，那么就会获取这个文件的文件描述符fd。然后再malloc一块内存空间保存在FILE，这个fd和malloc的内存空间都保存在FILE里面！！也就是下面这张图：

fork和缓冲区读写

现在，我这里有另外一个关于fork函数的问题。我们看下面这串代码:

我们生成程序后，将数据重定向到文件中。如果按照我们以往的经验的话，这里我们预测会打印四行内容，分别是hello printf、hello fprintf、hello fwrite、hello write。

但是，我们实际运行的结果如下:

如上图，我们可以发现c语言接口的打印都被打印了两次，只有write系统调用被打印了一次。

这是因为当使用重定向，重定向到了文件之后，缓冲区的刷新方案就变成了全缓冲，遇到不再刷新，而是等缓冲区被写满之后才刷新。

那么我们下载来证明一下重定向到文件是全缓冲的

首先我们写下面这个程序；

这个程序如果按照我们的猜想。前三秒不会打印任何数据，这些数据都会被打印到了缓冲区之中。当三秒过后， write会被打印。然后再五秒所有数据才会全部被打印。

我们先打开监视窗口进行观察:

然后运行这个程序，就会得到:

那么这是为什么呢？——首先我们知道，当我们三个c语言接口执行完的时候，数据都被写到了缓冲区中。而缓冲区也是在进程里面的，所以当fork创建子进程后，再刷新缓冲区，而刷新缓冲区就相当于数据的修改，需要进行写时拷贝。所以就有两份缓冲区，两个缓冲区的数据都被刷新后就产生了上面的现象！！！

模拟实现c语言标准库

为了模拟实现c语言的标准库，我们创建三个文件。这里的_my_func.h就相当于stdio.h这样的标准库，而_my_func.c就是用来模拟实现c标准库接口。

我们打开_my_func.h，首先做好预备工作。先让该头文件不可重复包含，也就是下面的ifdef, define, endif。然后再包含一个头文件string.h。我们先来简单的实现以下三个函数， _fopen, _fwrite, _fclose。

只包含fd的接口——不带缓冲区

下面是代码:

#include

//定义缓冲区最大长度
#define SIZE 1024

//flag用来表示刷新方案
#define FLUSH_NOw 0
#define FLUSH_LINE 1
#define FLUSH_ALL 2

typedef struct IO_FILE
{
  int fileno; //文件fd                                                       
  int flag;

  //输入缓冲区
  //char inbuffer[SIZE];
  //int in_pos;
  //输出缓冲区
  char outbuffer[SIZE];    
  int out_pos;    
}_FILE;

_FILE* _fopen(const char* filename, const char* mode);
int _fwrite(_FILE* fp, const char* s, int len);
void _fclose(_FILE* fp);
void _fflush(_FILE* fp);

#endif

然后我们定义FILE类型的结构体。但是为了区分标准库。我们这里改成_FILE（以后的函数等等为了区分都会加上"_")。

对于这个结构体里面的内容，根据我们前面讲到的只是可以知道，这里面一定有两个字段一个是文件描述符fd，一个是文件缓冲区。这里我们先将fd包含进来。如下图:

然后我们就可以先简单的实现一下fopen, fwrite, fclose函数了。

fopen

如下为代码:

_FILE* _fopen(const char* filename, const char* mode)
  {
    //先打开文件                       
    //open函数打开文件， 返回文件描述符。第二个参数是打开方式
    //先判断打开文件的方式。确定第二个参数                                   
    int f = 0;                
    int fd = -1; //一开始令fd 为-1
                                              
    if (strcmp(mode, "w") == 0) f = (O_CREAT|O_WRONLY|O_TRUNC); 
    else if (strcmp(mode, "a") == 0) f = (O_CREAT|O_WRONLY|O_APPEND);
    else if (strcmp(mode, "r") == 0) f = (O_RDONLY);
    else return NULL;
   
    //打开文件， 默认权限是FILEMODE
    fd = open(filename, f, FILEMODE);
    //如果fd是-1， 那么直接return。 否则就是正常打开文件。 正常进行操作
    if (fd == -1) return NULL;
    //else                          
    _FILE* fp = (_FILE*)malloc(sizeof(_FILE));
    if (fp == NULL) return NULL;//如果fp == NULL说明空间不够了。
    //else
    fp->fileno = fd;//让将fd赋值给fp的fd。
    return fp;
  }

fwrite

如下为代码:

 int _fwrite(_FILE* fp, const char* s, int len)                             
  {
    //fd， 要写入的字符串， 字节长度
    return write(fp->fileno, s, len);
  }

fclose

如下为代码:

  //关闭文件                     
  void _fclose(_FILE* fp)        
  {                              
    if (fp == NULL) return;      
    close(fp->fileno);           
    free(fp);                    
  }

我们自己实现一串代码进行测试, 打开的方式是清空写:

运行结果如下:

其实从上面的代码我们就能看到封装的好处。有了fopen， fwrite这些封装之后，以后再向文件中写内容，我们想要修改写入的方式，就不需要再使用O_RONLY、O_WRONLY这些标志了，直接使用w， a， r，然后程序就会自动帮助我们判断如何打开文件!!!

c语言的跨平台性

我们在上面实现的接口是符合linux环境的接口。如果我们再windows下，想实现同样的接口，那么为了能够在windows正常工作，就要实现一份适合在windows下面跑的代码。同样的macos也是一样的。这三份代码我们可以使用if else if, endif条件编译。如果在linux下面就是用linux下面的代码。如果在windows下面就是用windows下面的代码。如果在macos下面，就是用macos下的代码。这个就叫做c语言的跨平台性！！！

带缓冲区的c语言接口

我们在我们的接口里面加入缓冲区，下图是引入缓冲区的方法。图中的in_pos和out_pos是为了标记缓冲区的使用情况。它指向缓冲区已经使用的最后一个位置。这个位置的左边是已经使用的，右边是没有使用的。而且由于我们此次模拟实现的接口用不到输入缓冲区，所以将输入缓冲区注释掉。

接下来我们修改我们的代码:

fopen

首先修改fopen，要初始化缓冲区，那么就是将标记缓冲区使用情况的out_pos置为0. 就代表缓冲区没有被使用过。并且我们要初始化缓冲区的刷新方案。也就是_FILE结构体里面的flag。我们这里默认初始化为行刷新，下图的黄色代码就是初始化缓冲区。（只需要在原本的fopen下面添加黄色框框的代码就可以实现）

fwrite

如下图是写方法的含有缓冲区的实现方式。 就是先将数据拷贝到缓冲区中，然后判断刷新方式，是直接刷新，行刷新还是缓冲区满才刷新。刷新后标记位out_pos置为0.

下面是代码:


  //写方法
  int _fwrite(_FILE* fp, const char* s, int len)
  {
    //使用memcpy将数据拷贝到输出缓冲区中。 
    memcpy(&fp->outbuffer[fp->out_pos], s, len);
    fp->out_pos += len;
    //判断刷新方式
    //直接刷新
    if (fp->flag == FLUSH_NOw)
    {
      write(fp->fileno, fp->outbuffer, fp->out_pos);
      fp->out_pos = 0;
    }                                                                        
    //遇到反斜杠n刷新
    else if ((fp->flag == FLUSH_LINE) && (fp->outbuffer[fp->out_pos - 1] == '  
'))
    {
      //只要遇到反斜杠n就行刷新
      write(fp->fileno, fp->outbuffer, fp->out_pos);
      fp->out_pos = 0;
    }
    else if (fp->flag == FLUSH_ALL && fp->out_pos == SIZE) 
    {
      write(fp->fileno, fp->outbuffer, fp->out_pos);
      fp->out_pos = 0;
    }
    else return len;
    return len;
  }

fclose

关闭文件和之前没有什么区别

测试:

我们可以使用下面这个监控脚本，以及我们要测试的代码，来测试一下我们模拟实现的是否正确:
#include"_my_func.h"    
#include    
    
int main()    
{    
  _FILE* fp = _fopen("mytest.txt", "a");    
  if (fp == NULL) return 1;    
    
  int cnt = 10;    
  const char* mes = "hello linux
";    
  while (cnt)    
  {    
    _fwrite(fp, mes, strlen(mes));    
    sleep(1);    
    cnt--;    
  }    
  _fflush(fp);                                                               
  _fclose(fp);    
  return 0;    
}    
运行结果如下, 因为我们是以行刷新，并且每一秒都会追加一行。所以会出现下图的情况。验证结果我们的代码是正确的。

fflush

fflush这里我们也要模拟一下，博主模拟是为了应对全刷新的情况（并不是说fflush只是为了应对全刷新而存在的）。因为我们使用全刷新的时候，写到缓冲区的内容不容易被刷新出来。就如同下图我们已经运行了程序，但是仍旧刷新不出东西，也就是没有向文件写入:

那么实现fflush，我们要怎么实现呢?代码如下图:

代码:


  void _fflush(_FILE* fp)
  {
    if (fp->out_pos > 0) 
    {                                                                        
      write(fp->fileno, fp->outbuffer, fp->out_pos);
      fp->out_pos = 0;
    }
  }
  
  
  //关闭文件 
E>void _fclose(_FILE* fp)
  {
    if (fp == NULL) return;
    _fflush(fp);//因为关闭文件要将缓冲区中的东西都放出来。
    close(fp->fileno);
    free(fp);
  }

我们在运行就能在10秒胡进程退出的时候打出来了。下图就是测试——前十秒没有打印任何东西，但是后面打印了一串数据。这是因为进程退出的时候刷新了缓冲区。