Linux文件：缓冲区、缓冲区刷新机制 | C库模拟实现

一、缓冲区的作用

 缓冲区本质上就是一部分内存，用于提高效率！！

 对于文件的IO等操作，用户可以直接通过系统调用直接向操作系统进行读操作和写操作。但这样时间开销较大。所以在语言层面一般会维护一段语言级别的缓冲区，用于暂存数据。我们可以快速向缓冲区中写入数据，然后通过一定的刷新方式。将数据从语言级别的缓冲区中拷贝到内核缓冲区。大大提高使用者的效率！！

&mesp;同时由于缓冲区的存在，我们可以积累一定的数据后在统一发生，提高发送的效率！！

二、缓冲区的刷新机制

 缓冲区可以暂存数据，必定存在一定的刷新机制。常见的刷新机制由以下3种：

1. 无缓冲（立即刷新）
2. 行缓冲（行刷新）
3. 全缓冲（缓冲区全部写满后在刷新）

 其中显示器文件的刷新机制就是行刷新；对于磁盘上的文件则是全缓冲！！

除此之外，还存在一些特殊的刷新机制：

• 强制刷新。比如调用flush函数，以及printf在执行时，碰到/n时强制刷新！
• 进程退出时，一般会刷新缓冲区！

三、测试样例解析

3.1 测试样例和运行结果

 下面我们调用3个常见的C库函数和一个系统调用，都向显示器文件中进行写入。当写入操作完毕后创建子进程，我们来看看分别向显示器文件和磁盘文件中进行写入会发生什么？

int main()    
{    
    fprintf(stdout, "C: hello fprintf\n");    
    printf("C: hello printf\n");                                          
    fputs("C: hello fputs\n", stdout);    
    const char* buf = "system call: hello write\n";    
    write(1, buf, strlen(buf));    
    fork();    
    return 0;    
} 

---

 我们编译后，直接运行向显示器写入。然后通过输出重定向向log.txt磁盘文件进行写入：

【运行结果】：

3.2 结果分析

1、向显示器文件写入：

 当我们直接向显示器打印消息时，由于显示器的刷新机制是行刷新；并且我们所打印的字符串都带了‘\n(在printf中，'\n'是一种强制刷新的触发机制)。所以在fork()创建子进程前，数据已经全部被刷新！！

2、向磁盘文件进行写入：

 当我们重定向向磁盘文件写入数据时，缓冲区的刷新机制由行缓冲变成全缓冲。全缓冲也就意味着缓冲区变大，简单的几个字符串不足以将缓冲区写满，无法触发刷新机制。

 此时缓冲数据还在缓冲区。但当前缓冲区为C语言所提供的缓冲区，和操作系统无关。所以当前缓冲区中的数据依然属于进程。当fork()创建完子进程退出时，一般会刷新缓冲区。

 而刷新缓冲区本质上也是一种清空或者写入操作。所以父进程和子进程在退出前数据共享同一份；当退出时刷新缓冲区，对数据进行修改会发生写时拷贝，父、子进程各自私有一份。所以最后对于C函数调用会存在两份！！

 至于系统调用数据只打印一份的原因在于：系统调用在语言之下，数据不是向语言基本的缓冲区中写入；而是直接向操作系统内核缓冲区中写入。此时数据属于操作系统，不在属于进程！！

四、语言级别的缓冲区究竟在哪？

 下面我们以C为例。

 在此时样例中，我们已经知道对于库函数printf、fprintf自带缓冲区，而系统调用write则没有。（内核提提供的缓冲区此处不考虑）库函数时对系统调用的封装，这也意味着C所提供的缓冲区是二次加上的，由C本身所提供！！

 在C中，所有的IO函数都存在一个FILE指针，或者底层会封装FILE指针。而C的缓冲区的相关信息则保存在FILE结构体中，由FILE结构体来维护！！

【FILE结构体内容】：
 在/usr/include/stdio.h路径下，存在这样一段代码typedef struct _IO_FILE FILE。所以可以通过下面操作查找FILE：

【FILE结构体】：

在/usr/include/libio.h
struct _IO_FILE {
 int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags

 //缓冲区相关
 /* The following pointers correspond to the C++ streambuf protocol. */
 /* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
 char* _IO_read_ptr; /* Current read pointer */
 char* _IO_read_end; /* End of get area. */
 char* _IO_read_base; /* Start of putback+get area. */
 char* _IO_write_base; /* Start of put area. */
  char* _IO_write_ptr; /* Current put pointer. */
 char* _IO_write_end; /* End of put area. */
 char* _IO_buf_base; /* Start of reserve area. */
 char* _IO_buf_end; /* End of reserve area. */
 /* The following fields are used to support backing up and undo. */
 char *_IO_save_base; /* Pointer to start of non-current get area. */
 char *_IO_backup_base; /* Pointer to first valid character of backup area */
 char *_IO_save_end; /* Pointer to end of non-current get area. */
 struct _IO_marker *_markers;
 struct _IO_FILE *_chain;
 int _fileno; //封装的文件描述符
 
#if 0
 int _blksize;
#else
 int _flags2;
#endif
 _IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
 /* 1+column number of pbase(); 0 is unknown. */
 unsigned short _cur_column;
 signed char _vtable_offset;
 char _shortbuf[1];
 /* char* _save_gptr; char* _save_egptr; */
 _IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};

五、C库函数封装简单模拟

 这里博主仅简单封装小部分C库函数，主要用于验证缓冲区。
【待实现接口函数】：

extern myFILE *my_fopen(const char *path, const char *mode); //打开文件
extern int my_fwrite(const char *s, int num, myFILE *stream);             
extern int my_fflush(myFILE *stream);    //刷新文件
extern int my_fclose(myFILE *fp); //关闭文件

5.1 结构体封装内容

 这里我们在结构体中封装文件描述符、缓冲区、刷新策略以及有效数据范围！！

1. 这里我们实现的刷新策略只有三种：无缓冲、行刷新、全缓冲。
2. 有效数据范围本应该通过一些指针来维护，这里博主简化为：有效数据从0开始，用有效数据个数来间接代替有效数据范围！

#define SIZE 4096    
#define FLUSH_NONE 1    
#define FLUSH_LINE (1<<1)    
#define FLUSH_ALL  (1<<2)

typedef struct _myFILE    
{    
    char buffer[SIZE];	//缓冲区    
    int end;	//简化有效空间范围，从0开始    
    int flag;	//标志位，刷新策略    
    int fileno;    //文件描述符
}myFILE;

5.2 文件打开接口封装

 文件打开：

1. 首先我们需要先获取文件的打开方式（这里博主仅实现w、r、a3种）
2. 获取到打开方式后，我们需要判断文件是否存在。存在，直接通过系统调用正确打开文件；否则需要先创建文件。
3. 既然文件打开了，最后就是修改结构体myFILE中的内容了！（这里默认创建文件的刷新方式为行刷新 ）

【源代码】：

#define FILE_MODE 0666//文件创建默认权限

myFILE *my_fopen(const char *path, const char *mode)
{
    int flag = 0;
    int fd = 0;

	//获取文件的打开方式
    if(strcmp(mode, "r") == 0)
    {
        flag |= O_RDONLY;
    }
    else if(strcmp(mode, "w") == 0)
    {
        flag |= (O_CREAT | O_WRONLY | O_TRUNC);
    }
    else if(strcmp(mode, "a") == 0)
    {
        flag |= (O_CREAT | O_WRONLY | O_APPEND);
    }
    else
    {
        //do nothing
    }  
 //-------------------------------------------------------------------------        
     //打开文件
    if(flag & O_CREAT)//文件需要被创建
    {
        fd = open(path, flag, FILE_MODE);                                 
    }
    else
    {
        fd = open(path, flag);
    }
    //文件打开失败
    if(fd < 0)
    {
        errno = 2;//没有该文件
        return NULL;
    }
 //------------------------------------------------------------------------- 
	//修改结构体内容，默认创建文件的刷新方式为行刷新 
    myFILE *fp = (myFILE*)malloc(sizeof(myFILE));
    if(!fd)
    {
        errno = 3;
        return NULL;
    }

    fp->flag = FLUSH_LINE;
    fp->fileno = fd;
    fp->end = 0;
    return fp;
}
        

5.3 文件关闭和文件刷新

1. 关闭文件后，进程一般会将文件中的内容进行刷新。
2. 但对于刷新而言，如果文件中由内容需要被刷新，我们直接调用系统调用接口即可完成！！

int my_fflush(myFILE *stream)
{
    if(stream->end > 0)//存在内容需要刷新
    {
        write(stream->fileno, stream->buffer, stream->end);
        //fscnc(stream->fileno);//强制内核缓冲区刷新
        stream->end = 0;
    }
    return 0;
}

int my_fclose(myFILE *stream)
{
    my_fflush(stream);//刷新文件内容，是否存在内容需要刷新我们由my_fflush函数来判断
    return close(stream->fileno);
}

5.4 向显示器文件写入

 C库函数中fwrite的原型如下，这里博主简化直接传递数据个数，大小为1byte！！

1. 向显示器文件中写入时，我们需要判断是否存在字符\n是会触发`fwrite’刷新机制，刷新缓冲区！

int my_fwrite(const char *s, int num, myFILE *stream)                     
{
    //写入
    memcpy(stream->buffer + stream->end, s, num + 1);
    stream->end += num;

    //判断是否需要刷新
    int i = stream->end - 1;
    if((stream->flag & FLUSH_LINE) && stream->end>0)
    {
        while(i)//从后往前遍历查找是否存在'\n'
        {
            if(stream->buffer[i] == '\n')
            {
                 my_fflush(stream);
                 break;
            }
            i--;
        }
    }
    return i == 0 ? 0 : num;//返回刷新个数
}