Linux文件缓冲区

本章gitee代码仓库：重定向、模拟C语言文件标准库

1. 缓冲区现象

我们这里分别调用了4个差不多的函数，但是结果是有一定差别的，这些其实就是因为有缓冲区的存在，导致了现象的不同。

2. 用户级和系统级缓冲区

C语言提供访问文件的接口，本质上都是对系统提供的接口进行封装。上面的func3函数，我们将一号文件描述符关闭之后，C接口的内容都没有在显示器上显示，而系统接口write不受影响，正常显示。

这个就能说明，C语言提供的缓冲区，并不是系统级别的缓冲区。例如printf、fprintf、fwrite这些库函数，都是先将数据写入到C语言提供的缓冲区当中，然后再到合适的时候，通过write将内容刷新带内核的缓冲区当中。

所以这里close(1)将一号文件描述符关闭之后，再想让write写入，那就写不进去了，而在此之前write自己的内容，是直接写入系统缓冲区的，所以我们就能看到通过系统调用write写的内容不受影响，而C库函数的内容全部都没有被刷新出来。

3. 缓冲区刷新

缓冲区刷新分为三种：

1. 无缓冲：直接刷新

2. 行缓冲：遇到换行符(\n)刷新

   一般向显示器打印采用行刷新

3. 全缓冲：缓冲区满了之后再刷新

   向文件写入一般采用全缓冲

上面的func4，因为我们字符串后面都跟上了\n，采用的行刷新，和func3不一样，遇到\n就刷新缓冲区，所以内容能够全部刷新出来。

当然，在进程退出的时候，也会再刷新一次缓冲区。

4. 为什么要有缓冲区

我们现在有很多快递驿站，这些驿站就可以理解为缓冲区，有了驿站的存在，我们寄快递的时候，直接将快递放到驿站，填好地址信息，我们就可以走了，就不需要我们自己亲自去将这个东西给对方；而拿快递的时候也是，有了驿站的存在，我们可以选择在自己有空的时候去拿，而不是说快递一到，我们就得立马去，这样就能极大的提高我们的效率。

缓冲区也是如此，我们的库函数将内容交给我们的缓冲区后，然后再由缓冲区将内容在合适的时候，调用系统接口，把内容刷新到系统。这样就能够提高用户的效率，让C语言函数的接口更快。

fprintf、printf、scanf这些，都是叫格式化输入输出接口，我们向显示器打印整数1024，在我们看来是一个整数，其实本质上是字符。先将我们的内容作为一个整体，格式化刷新到C的缓冲区，然后统一刷到内核当中。

所以，有缓冲区的存在，也能更好地配合我们的格式化输入输出。

在C语言的文件操作里面，是绕不开这个struct FILE结构体的，所以里面也封装了缓冲区字段。

例如我们在C语言当中一次性打开了5个文件，那么就会有5个对应的缓冲区。

这个FILE是语言层面的，语言层面都是属于用户的，所以这个缓冲区是属于用户层的

5. 文件打印的全缓冲

有了这些知识，我们再来看上面的func2，我们在程序退出之前fork创建子进程，在显示器上输出的是正常的，但是如果我们将内容重定向到文件当中，我们发现C库函数的接口都输出了2次。

这是因为向文件打印时，刷新方案变成了全缓冲。

当变为全缓冲之后，遇到\n就不再刷新。而这里fork创建子进程，子进程会将父进程的代码和数据拷贝一份，当然这里缓冲区的数据也会拷贝。因为是全缓冲，这里的缓冲区里面是有数据的。

我们先来验证一下这个，不创建子进程，向文件打印：

void func2()
{
  const char *fstr="hello fwrite\n";
  const char *str="hello write\n";
  printf("hello\n");
  sleep(1);
  fprintf(stdout,"hello fpf\n");
  sleep(1);
  fwrite(fstr,strlen(fstr),1,stdout);
  sleep(1);
  write(1,str,strlen(str));
  sleep(3);
  //fork();
}

可以看到，这里向文件打印，虽然加了\n但并没有刷新，而是采用的全缓冲，等进程结束之后，全部刷新了。

所以这里拷贝的缓冲区进行写时拷贝，父进程退出刷新一次，子进程退出刷新一次，所以我们就能看到C接口的信息会被刷新2次。而我们输出到显示的时候，因为是行缓冲，每次直接刷新了，到子进程的时候，缓冲区里面没有数据了，所以就输出一次。

6. 模拟实现C语言文件标准库

简易实现：

#include"Mystdio.h"
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

#define FILE_MODE 0666

_FILE * _fopen(const char*filename,const char*flag)
{
  assert(filename);
  assert(flag);
  int f = 0;
  int fd = -1;
  if(strcmp(flag,"w") == 0)
  {
    f = (O_CREAT|O_WRONLY|O_TRUNC);
    fd = open(filename,f,FILE_MODE);
  }
  else if(strcmp(flag,"a") == 0)
  {
    f = (O_CREAT|O_WRONLY|O_APPEND);  
    fd = open(filename,f,FILE_MODE);
  }
  else if(strcmp(flag,"r") == 0)
  {
    f = O_RDONLY;
    fd = open(filename,f);
  }
  else
    return NULL;
 
  if(fd == -1)  return NULL;
  _FILE*fp = (_FILE*)malloc(sizeof(_FILE));
  fp->fileon = fd;
  fp->flag = FLUSH_ALL;  
  fp->out_pos = 0;  //初始缓冲区没有内容
  return fp;
}
int _fwrite(_FILE*fp,const char*s,int len)
{
  memcpy(&fp->outbuffer[fp->out_pos],s,len);
  fp->out_pos+=len;
  if(fp->flag & FLUSH_NOW)
  {
    write(fp->fileon,fp->outbuffer,fp->out_pos);
    fp->out_pos = 0;
  }
  else if(fp->flag&FLUSH_LINE)
  {
   if(fp->outbuffer[fp->out_pos-1] == '\n')
   {
     write(fp->fileon,fp->outbuffer,fp->out_pos);
     fp->out_pos = 0;
   }
  }
  else if(fp->flag&FLUSH_ALL)
  {
    if(fp->out_pos == SIZE)
    {
      write(fp->fileon,fp->outbuffer,fp->out_pos);
      fp->out_pos = 0;
    } 
  }
  return len;
}

void _fflush(_FILE*fp)
{
  if(fp->out_pos>0)
  {
    write(fp->fileon,fp->outbuffer,fp->out_pos);
    fp->out_pos = 0;
  }
}

void _fclose(_FILE*fp)
{
  if(fp == NULL)  return;
  _fflush(fp);
  close(fp->fileon);
  free(fp);
}