【Linux】缓冲区理解-编程知识

需要云服务器等云产品来学习Linux的同学可以移步/–>腾讯云<–/官网，轻量型云服务器低至112元/年，优惠多多。（联系我有折扣哦）

文章目录

1. 一个奇怪的现象
2. 为什么要有缓冲区
3. 缓冲区的刷新策略
4. 缓冲区在哪里
5. 实现一个简易的C语言FILE结构体
6. 缓冲区理解

1. 一个奇怪的现象

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main()
{printf("hello printf\n");fprintf(stdout, "hello fprintf\n");fputs("hello fputs\n", stdout);const char* msg = "hello write\n";write(1, msg, strlen(msg));fork();return 0;
}

这个运行结果看起来是没有任何问题的。那么现在我们把运行结果进行一次重定向

明显看到打印出来的数据变多了，这是什么原因呢？

这里我们把fork给去掉试试？

所以可以推测出来一定是fork的问题。

仔细观察可以发现，出现重复打印的是C语言的接口，所以应该是C语言的问题

这里面实际上是一个C语言缓冲区的问题，接下来我们来了解一下这个C语言缓冲区的相关内容

2. 为什么要有缓冲区

1. 缓冲区是什么？

缓冲区本质上就是一段内存 在内存中提前预留一段空间，用来存储即将输入或者输出的内容，这一段预留的空间就是缓冲区。

2. 为什么要有缓冲区？

我们知道内存相对于外设来说是一个高速设备，如果每次IO都要从外设读取或者直接写到外设，这种等待的时间太长了（相对来说），所以就干脆预留一段空间，将所有需要写入到外设的数据拷贝到内存的某个空间（缓冲区），然后由操作系统决定什么时候真正写入到外设。这种方式能够很大的提高效率。这个拷贝数据的过程我们并不需要手动实现，而是通过fwrite来实现，那么实际上这个fwrite的本质就是一个拷贝功能的函数，fread同理

**通过这种策略，数据可以直接拷贝到缓冲区，高速设备不用在等待低速设备，提高计算机的效率。 **

3. 缓冲区的刷新策略

上文中我们说到，缓冲区的数据什么时候真正写到磁盘中是由操作系统决定的，那么操作系统将缓冲区的内容写到磁盘中遵循什么样的策略呢？

缓冲区的刷新策略：

1. 立即刷新（无缓冲）缓冲区中一出现数据就刷新到外设中——这种很少出现

2. 行刷新（行缓冲）——数据按行刷新，每拷贝一行数据就刷新一次，显示器采用的就是这种刷新策略，因为显示器是给人看了，而按行刷新符合人的阅读习惯，同时刷新效率也不会太低

3. 缓冲区满刷新（全缓冲）——待数据把缓冲区填满后再刷新，这种刷新方式效率最高，一般应用于磁盘文件

两种特殊情况：

用户使用 fflush 等函数强制进行缓冲区刷新；
一般进程推出后缓冲区会被刷新

4. 缓冲区在哪里

把思绪回到文章开头的那个现象中，有了现在的知识储备，我们再来思考一下这个现象：加上fork之后，向显示器上打印的数据有四条，向文件中写入的数据有七条，那么肯定是有三条数据在缓冲区中没有被刷新出来。注意：这三条数据是C语言提供的接口产生的，系统调用的接口并没有出现这种现象，所以这个缓冲区肯定是在语言层的。

实际上，C语言封装了一个FILE结构体，在FILE结构体中，除了我们之前说的fd之外，还维护了一个缓冲区

我们来找一找FILE结构体的源码

在/usr/include/stdio.h中

在/usr/include/libio.h中

所以现在我们再来解释一下这个奇怪的现象：

一般C库函数写入文件的时候是全缓冲的，但是写入到显示器是行缓冲
printf fwrite库函数是自带缓冲区的，当发生了重定向之后，写入显示器的行缓冲就会变成全缓冲
所以我们放入缓冲区的数据不会被立刻刷新，直到fork之后，这个缓冲区也被拷贝了两份
进程退出之后，所有的缓冲区数据会被刷新，写入到文件中，包括子进程的缓冲区，所以就有了两份数据
由于这个缓冲区是语言层的，write系统调用并没有这个缓冲区，所以write的数据不会被拷贝两份

简单总结来说：重定向导致刷新策略发生了改变（由行缓冲变成了全缓冲）。同时发生了写时拷贝，缓冲区的数据变成了两份一样的，父子进程各自刷新，出现重复写入同一份数据。

5. 实现一个简易的C语言FILE结构体

注意，这里实现的只是demo级的FILE，当然会有很多bug，理解其中意思就行。

/* myStdio.h */
#pragma once#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>#define SIZE 1024 // 缓冲区容量// 缓冲区刷新策略
#define SYNC_NOW 1
#define SYNC_LINE 2
#define SYNC_FULL  4typedef struct _FILE //定义的FILE结构体
{int fileno;           //文件描述符int flag;             //缓冲区刷新方式char buffer[SIZE];    //缓冲区int cap;              //缓冲区容量int size;             //缓冲区写入的数据大小
}FILE_;//这里我们自己实现的函数和结构体在后面加了下划线
FILE_ *fopen_(const char* path_name, const char* mode);
void fclose_(FILE_* fp);
void fflush_(FILE_* fp);
void fwrite_(const void *ptr, int num, FILE_* fp);

/* myStdio.c */
#include "myStdio.h"
FILE_ *fopen_(const char* path_name, const char* mode)
{int flags = 0; // 打开方式int defaultMode = 0666; // 默认的创建文件权限//设置打开的方式if(strcmp(mode, "r") == 0){flags |= O_RDONLY;}else if(strcmp(mode, "w") == 0){flags |= (O_WRONLY | O_CREAT | O_TRUNC);}else if(strcmp(mode, "a") == 0){flags |= (O_WRONLY | O_CREAT | O_APPEND);}else{//do nothing}//按照不同方式打开文件并记录文件的fdint fd = 0;if(flags & O_RDONLY) // 只读fd = open(path_name, flags);else //可能要创建fd = open(path_name, flags, defaultMode);if(fd < 0){//文件打开失败char* str = strerror(errno);write(2, str, strlen(str));return NULL;}//文件打开成功，构造FILE*对象并填充内容FILE_* fp = (FILE_*)malloc(sizeof(FILE_));if(fp == NULL){char* str = strerror(errno);write(2, str, strlen(str));return NULL;}fp->fileno = fd;fp->cap = SIZE;fp->size = 0;memset(fp->buffer, 0, SIZE);fp->flag = SYNC_LINE;return fp;
}void fflush_(FILE_* fp)
{//如果缓冲区有内容的话执行写入if(fp->size > 0){write(fp->fileno, fp->buffer, fp->size);fp->size = 0;}
}void fclose_(FILE_* fp)
{//刷新缓冲区fflush_(fp);//关闭文件close(fp->fileno);//释放FILE结构体free(fp);fp = NULL;
}
void fwrite_(const void *ptr, int num, FILE_* fp)
{//写到缓冲区(本质上是拷贝，吧数据从ptr中拷贝到fp->buffer)memcpy(fp->buffer + fp->size, ptr, num);fp->size += num;//执行刷新策略if(fp->flag & SYNC_NOW) //无缓冲{if(fp->size != 0){write(fp->fileno, fp->buffer, fp->size);fp->size = 0;//清空缓冲区}}else if(fp->flag & SYNC_LINE) // 行缓冲{if(fp->buffer[fp->size - 1] == '\n') //这里不考虑 abcd\nefg{write(fp->fileno, fp->buffer, fp->size);fp->size = 0;//清空缓冲区}}else if(fp->flag & SYNC_FULL) // 全缓冲{if(fp->size == fp->cap){write(fp->fileno, fp->buffer, fp->size);fp->size = 0;//清空缓冲区}}else{//do nothing}
}

/* mian.c */
#include "myStdio.h"int main()
{FILE_* fp = fopen_("./log.txt", "w");if(fp == NULL){return 1;}const char* msg = "hello world\n";fwrite_(msg, strlen(msg), fp);fclose_(fp);return 0;
}

6. 缓冲区理解

实际上我们上文中一直在讲的是都是语言层面的缓冲区，但是**操作系统也是有缓冲区的** 。

我们在把一串信息写入到外设（磁盘）中的时候，经历了以下过程

通过fputs、fprintf、fwrite等函数把massage写入到**FILE结构体中的缓冲区 **；
通过系统调用write将FILE结构体中的缓冲区内容写入到OS内核缓冲区中；
由OS决定什么时候将OS内核的数据真正写入到磁盘中；

那么，出现一个问题，如果在第二步结束之后，操作系统宕机了，怎么办？

可能会导致数据丢失。

那么如果在一个对数据丢失0容忍的系统内出现这个问题咋办？

有一个系统调用可以解决这个问题：fsync

这个系统调用的功能就是：强制将内核缓冲区中的数据立刻同步到外设中，而不再采用操作系统的刷新策略

所以，我们上文中实现的fflush_函数事实上得加上这句话

void fflush_(FILE_* fp)
{//如果缓冲区有内容的话执行写入if(fp->size > 0){write(fp->fileno, fp->buffer, fp->size);fp->size = 0;fsync(fp->fileno);}
}

本节完…