【Linux】文件的内核级缓冲区、重定向、用户级缓冲区(详解)

一.文件内核级缓冲区

在一个struct file内部还要有一个数据结构-----文件的内核级缓冲区

打开文件，为我们创建struct file，与该文件的所对应的操作表函数指针集合，还要提供一个文件的内核级缓冲区

1.write写入具体操作

当我们去对一个文件写入的时候，那么是如何进行写入的呢？

比如上层调用write(3,"hello word",..),根据PCB找到file_struct,然后找到fd_array[]，然后拿到文件描述符表，找到目标3号文件，然后把字符串“hello word”，拷贝到文件内核级缓冲区，write给我们进行拷贝，file会找到ops函数指针集合中write方法，然后通过这个方法，把我们文件内核及缓冲区的内容刷新到我们对应的外设中，当然由文件内核级缓冲区刷新到外设的过程什么时候刷新是由OS自主决定的，

所有write本质是一个拷贝函数，从用户拷贝到内核，文件这些数据结构都是OS给我们提供的。

这就是我们平时写文件的时候，比如word文档的时候，已经键盘里进行输入了，为什么最后还要进行保存，保存是在干什么？写只是把数据写到文件的内核级缓冲区，保存是把内容从缓冲区刷新到外设，这个过程叫做写入！！！

补充：每个文件都有属于自己的文件操作表，都有属于自己的内核级缓冲区。

2.read读取具体操作

当我们去对一个文件写入的时候，那么是如何进行写入的呢？

上层调用read(3,buffer,...)，在读的时候本质是在做什么呢？

找到进程，找到文件描述符表，找到文件，然后他会检测当前数据是在文件内核级缓冲区内，还是在磁盘上，如果在读的时候，数据没在缓冲区里面，就会触发我们read方法，把数据从磁盘读到缓冲区里，然后read开始进行把缓冲区里的数据拷贝到buffer中。

读到缓冲区之后，才能完成拷贝，这个过程，很明显就会阻塞住，这就是我们平常调read会阻塞的原因，

最典型scanf，调用scanf时，scanf对应的外设中根本没有数据，此时调用scanf就会阻塞，当你一输入的时候，这个数据里面就被读到缓冲区里，然后上层通过read就把数据从内核拷贝到用户，本质上也是拷贝函数！！！

3.修改的具体操作

如果要进行修改文件内容的一部分，要修改的话我们进程是没办法直接对磁盘里的文件进行修改，所以要修改，第一步，把文件的相关数据加载到内核级缓冲区内，然后读到用户空间，修改完后，再写回内核级缓冲区，再刷新到外设，修改的本质也是先读取，再写入，

读取由修改都是要把数据从外设读到缓冲区内进行操作，

换言之，我们对应的文件struct file里包含文件属性，操作表，每个文件的内核级缓冲区。

所以把我们外部设备，当我们打开这个文件，如果文件里本来就有内容，OS可以自主决定什么时候把数据从内核级缓冲区刷新到外设，那可不可以自主决定提前把文件数据一部分进行预加载呢？

也就是说，还没访问到这个数据的时候，提前给预加载了，这个是可以的。

4.为什么要存在这个缓冲区呢？

因为内存的的操作非常块，外设的操作非常慢，

如果每一次写入一部分数据，都要进行一次IO访问外设，如果写一百次就要一百次IO，这样耗费的时间就特别长，而我们数据从内存拷贝到内存这个速度是特别快的，我们把一百次的数据积累到一块，统一坐刷新，这样就可以节省99次IO的时间，

所以缓冲区的存在，提高了效率！！！！

这时刷新，要是读取呢？

在OS有空闲时间的时候，在进行数据读取的时候，OS也可以自主决定把文件内一部分数据提前预加载到缓冲区里，上层在进行读取的时候，就能直接进行读取，这样就把IO的时间成本嫁接在OS空闲的时候，当OS忙的时候就可以直接从缓冲区里进行读，就不用再进行加载，这样也提高了效率。

总结：缓冲区存在的意义就是变相的提高IO的效率！！！！

我们来看看内核源代码，来看看内核级缓冲区的存在：

二.重定向

1.认识

先说一个结论：进程打开一个文件，需要给文件分配新的的文件描述符fd，fd的分配规则是，最小的没有被使用的fd！！！

我们看看正常打开几个文件，他们fd是多少：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>int main()
{int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);int fd2 = open("log.txt2",O_WRONLY | O_CREAT | O_APPEND,0666);int fd3 = open("log.txt3",O_WRONLY | O_CREAT | O_APPEND,0666);int fd4 = open("log.txt4",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);printf("fd2: %d\n",fd2);printf("fd3: %d\n",fd3);printf("fd4: %d\n",fd4);close(fd1);close(fd3);close(fd3);close(fd4);return 0;
}

正常打开文件，是从3开始依次向后，这时为什么呢？在上一篇文件说到，因为进程启动，会默认打开三个输入输出流，参考：【linux】文件描述符fd。

当我们试着把0和2号文件进行关闭，再来看看结果：
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>int main()
{close(0);close(2);int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);int fd2 = open("log.txt2",O_WRONLY | O_CREAT | O_APPEND,0666);int fd3 = open("log.txt3",O_WRONLY | O_CREAT | O_APPEND,0666);int fd4 = open("log.txt4",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);printf("fd2: %d\n",fd2);printf("fd3: %d\n",fd3);printf("fd4: %d\n",fd4);close(fd1);close(fd3);close(fd3);close(fd4);return 0;
}
这时发现文件打开就变成0 2 3 4，根据fd分配规则，最小的没有被使用，因为提前关闭了0和2，所以最小的没被使用的 fd就是0和2，从0和2开始进行分配。

那么如果把一号文件描述符关掉，结果如下：

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>int main()
{close(1);int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);int fd2 = open("log.txt2",O_WRONLY | O_CREAT | O_APPEND,0666);int fd3 = open("log.txt3",O_WRONLY | O_CREAT | O_APPEND,0666);int fd4 = open("log.txt4",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);printf("fd2: %d\n",fd2);printf("fd3: %d\n",fd3);printf("fd4: %d\n",fd4);close(fd1);close(fd3);close(fd3);close(fd4);return 0;
}

把一号文件描述符关掉，后来打开log.txt1文件，然后进行printf打印，原则上应把数据写到log.txt1中去，因为使用了1号描述符，printf就是往标准输出里打印的，所以应该像log.txt1中去打印，因为printf只认1号描述符，而不是认这个1号描述符指向哪，

如下图：

可是我们发现log.txt1文件为空，没有内容，为什么没有像我们预料的那样，打印到文件中去呢？

关闭1，后open打开文件log1，根据fd的分配规则，1就会指向log1，可是在我们上层printf，printf本质是默认像stdout里打印的，printf认的是stdout->_fileno = 1，这是提前保存好的，

在系统调用关闭了1，打开log1，printf不知道底层做了这个操作，然后打印就打印到log1中，所以，在进程启动的时候，stdout->_fileno = 1已经初始化完了，在下层进行狸猫换太子，1指向log1，正常情况下，打印内容应该给我们打印到log1文件中，可是我们看到结果并没有这样，

我们先把上述情况给复现出来：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>int main()
{close(1);int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);int fd2 = open("log.txt2",O_WRONLY | O_CREAT | O_APPEND,0666);int fd3 = open("log.txt3",O_WRONLY | O_CREAT | O_APPEND,0666);int fd4 = open("log.txt4",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);printf("fd2: %d\n",fd2);printf("fd3: %d\n",fd3);printf("fd4: %d\n",fd4);fflush(stdout);close(fd1);close(fd3);close(fd3);close(fd4);return 0;
}

给代码加fflush(stdout)，就可以，什么原因，我们最后再说！！！因为我们还要有后续知识坐铺垫！！！

printf本来应该像显示器文件写入，结果却写入到文件中？

上层stdout封装的1不变，把1号下标内容指向显示器改成指向文件，这个动作我们就叫做重定向。

重定向的原理：更改我们文件描述符表特定下标里面的内容，在重定向的过程，上层代码毫不知情，

重定向本质：就是上层不知道也不关心，把一个进程对应多个文件中，特点的下标里的内容相互做一下修改，就能完成重定向。

2.操作

上面代码通过关闭打开文件来重定向操作，并不优雅，有没有直接进行重定向操作呢？
函数dup2，把底层数组里面的地址进行拷贝。

把oldfd拷贝到newfd地位置，可以这样理解，newfd是新的位置，oldfd是老位置。

把要重定向的给覆盖了，原本指向的文件会自动关闭，要拷贝的那个默认是没有关的，但是如果不关会被两个指针指向，但是一个文件可以被多个指针共同指向，struct file里面有个f_count，叫做引用计数，有一个指针指向，引用计数就为1，两个指向，引用计数就为2，当引用计数为0时，才会进行关闭。

1.输出重定向代码示范：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{int fd = open("log.txt",O_WRONLY | O_CREAT | O_TRUNC,0666);dup2(fd ,1);printf("hello word\n");fprintf(stdout,"hello bit\n");fputs("111111\n",stdout);char *message = "aaaaaa\n";fwrite(message,1,strlen(message),stdout);write(1,"cccccc\n",7);return 0;
}

第一，这里为什么没有加fflush却可以打印到文件中，这是因为，没有对文件进行关闭，当进程结束后，会自动刷新缓冲区里的内容，后面会讲，

第二，我们cccccc是最后写入的却第一个打印上去，因为write是无缓冲的系统调用，会直接讲数据写入到文件中，前面几个打印都是会会先打印用户级缓冲区，后面会具体讲用户级缓冲区，也就是write不需要经过用户级缓冲区，直接将用户指定的数据从用户空间的缓冲区发送到内核缓冲区。

2.我们来看看追加重定向示范：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{int fd = open("log.txt",O_WRONLY | O_CREAT | O_APPEND,0666);dup2(fd ,1);printf("hello word\n");fprintf(stdout,"hello bit\n");fputs("111111\n",stdout);char *message = "aaaaaa\n";fwrite(message,1,strlen(message),stdout);write(1,"cccccc\n",7);return 0;
}

追加重定向和输出重定向，没有区别，只是打开文件方式不一样！！！

3.来看看输入重定向：

正常的read是从键盘进行读取，read返回值是实际读到的字节数

看看正常read使用方法：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{// int fd = open("log.txt",O_RDONLY);char buffer[1024];size_t s = read(0,buffer,sizeof(buffer));if(s > 0){buffer[s] = 0;printf("stdin redir: \n%s\n",buffer);}return 0;
}

接下来示范输入重定向：

下面代码前提的刚才log.txt文件内容是刚才追加重定向的内容，现在将0指向的位置重定向为fd文件地址，也就是从log.txt文件进行读取：
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{int fd = open("log.txt",O_RDONLY);dup2(fd,0);char buffer[1024];size_t s = read(0,buffer,sizeof(buffer));if(s > 0){buffer[s] = 0;printf("stdin redir: \n%s\n",buffer);}return 0;
}

4.在之前模拟实现shell的基础上增加重定向功能

所以在命令行上 ./myfile>log.txt进行重定向，可以通过命令行参数的方式获取 >log.txt在程序中进行判断，来确定是要坐什么重定向，然后把这个文件以特定的形式打开，这样就在命令行上完成重定向，

代码如下：

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
using namespace std;enum
{FILE_NOT_EXISTS = 1,OPEN_FILE_ERROR = 2,};const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;// 全局的命令行参数表
char *gargv[argvnum];
int gargc = 0;// 我自己的环境变量
char *genv[envnum];// 全局变量,用来表示退出结果
int lastcode = 0;// 全局的工作路径
char pwd[basesize];
char pwdenv[basesize * 2];// 全局变量与重定向有关
#define NoneRedir 0   // 没有重定向
#define InputRedir 1  // 输入重定向
#define OutputRedir 2 // 输出重定向
#define AppRedir 3    // 追加重定向int redir = NoneRedir;
char *filename = nullptr;// #define TrimSpace(pos) \
//     do                 \
//     {                  \
//         pos++;         \
//     \pos))
// isspace检查字符是否为空格
#define TrimSpace(pos)             \do                             \{                              \while (isspace(*pos))      \{                          \pos++;                 \}                          \} while (0)string GetName()
{string name = getenv("USER");return name.empty() ? "None" : name;
}string GetHostName()
{char hostname[basesize];gethostname(hostname, sizeof(hostname));return gethostname(hostname, sizeof(hostname)) != 0 ? "None" : hostname;
}string GetPwd()
{// getcwd获取当前工作路径if (nullptr == getcwd(pwd, sizeof(pwd)))return "None";// 讲获取的当前路径输入到pwdenvsnprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);// 导入环境变量putenv(pwdenv);return pwd;// string pwd = getenv("PWD");// return pwd.empty() ? "None" : pwd;
}string LastDir()
{string curr = GetPwd();if (curr == "/" || curr == "None")return curr;// /home/xzl/xxxsize_t pos = curr.rfind("/");if (pos == std::string::npos)return curr;return curr.substr(pos + 1);
}string MakeCommandLine()
{char Command_Line[basesize];snprintf(Command_Line, basesize, "[%s@%s %s]#",GetName().c_str(), GetHostName().c_str(), LastDir().c_str());return Command_Line;
}// 打印命令行提示符
void PrintCommandLine()
{printf("%s", MakeCommandLine().c_str());fflush(stdout);
}
// 获取用户命令
bool GetCommandLine(char command_buffer[])
{// 获取字符串char *result = fgets(command_buffer, basesize, stdin);if (!result){return false;}command_buffer[strlen(command_buffer) - 1] = 0;if (strlen(command_buffer) == 0)return false;return true;
}//  分析命令
void ParseCommandLine(char command_buffer[], int len)
{memset(gargv, 0, sizeof(gargc));gargc = 0;// 重定向redir = NoneRedir;filename = nullptr;// printf("command start: %s\n", command_buffer);//"ls -a -n -l"//"ls -a -n -l" > file.txt//"ls -a -n -l" < file.txt//"ls -a -n -l" >> file.txt// ls -a -n -l <int end = len - 1;while (end >= 0){if (command_buffer[end] == '<'){redir = InputRedir;command_buffer[end] = 0;char *filestart = &command_buffer[end];filestart++;TrimSpace(filestart);if (*filename == 0){filename = nullptr;}break;}else if (command_buffer[end] == '>'){if (command_buffer[end - 1] == '>'){redir = AppRedir;command_buffer[end] = 0;command_buffer[end - 1] = 0;filename = &command_buffer[end];filename++;TrimSpace(filename);if (*filename == 0){filename = nullptr;}break;}else{redir = OutputRedir;command_buffer[end] = 0;filename = &command_buffer[end];filename++;TrimSpace(filename);if (*filename == 0){filename = nullptr;}break;}}else{end--;}}// printf("redir: %d\n", redir);// printf("filename: %s\n", filename);// printf("command end: %s\n", command_buffer);const char *seq = " ";gargv[gargc++] = strtok(command_buffer, seq);while (gargv[gargc++] = strtok(nullptr, seq));gargc--;
}void debug()
{printf("argc: %d\n", gargc);for (int i = 0; gargv[i]; i++){printf("argv[%d]: %s\n", i, gargv[i]);}
}// 执行命令
bool ExecuteCommand()
{pid_t id = fork();if (id < 0)return false;else if (id == 0){// 重定向由子进程来做，不能影响shell// 程序替换会不会影响重定向// 0.先判断  重定向//printf("filename:%p\n", &filename);if (redir == InputRedir){if (filename){int fd = open(filename, O_RDONLY);if (fd < 0){exit(OPEN_FILE_ERROR);}dup2(fd, 0);}else{exit(FILE_NOT_EXISTS);}}else if (redir == OutputRedir){if (filename){int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);if (fd < 0){exit(OPEN_FILE_ERROR);}dup2(fd, 1);}else{exit(FILE_NOT_EXISTS);}}else if (redir == AppRedir){if (filename){int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);if (fd < 0){exit(OPEN_FILE_ERROR);}dup2(fd, 1);}else{exit(FILE_NOT_EXISTS);}}else{// 没有重定向}// 子进程// 执行命令execvpe(gargv[0], gargv, genv);// 退出exit(0);}int status = 0;pid_t rid = waitpid(id, &status, 0);if (rid > 0){if (WIFEXITED(status)){lastcode = WEXITSTATUS(status);}else // 表示代码异常退出{lastcode = 100;}return true;}return false;
}void AddEnv(const char *item)
{int index = 0;while (genv[index]){index++;}genv[index] = (char *)malloc(strlen(item) + 1);strncpy(genv[index], item, strlen(item) + 1);index++;genv[index] = nullptr;
}// 在shell中
// 有些命令，必须由子进程执行
// 有些命令，不能由子进程执行，要由shell自己执行 -----内建命令 built command
bool CheckAndExecBuiltCommand()
{// 不能让子进程进行，因为子进程退出就结束了，并不能影响下一个进程的工作路径if (strcmp(gargv[0], "cd") == 0){if (gargc == 2){chdir(gargv[1]);lastcode = 0;}else{lastcode = 1;}return true;}else if (strcmp(gargv[0], "export") == 0){if (gargc == 2){AddEnv(gargv[1]);lastcode = 0;}else{lastcode = 2;}}else if (strcmp(gargv[0], "env") == 0){for (int i = 0; genv[i]; i++){printf("%s\n", genv[i]);}lastcode = 0;return true;}else if (strcmp(gargv[0], "echo") == 0){if (gargc == 2){// echo $?// echo $PATH// echo helloif (gargv[1][0] == '$'){if (gargv[1][1] == '?'){printf("%d\n", lastcode);lastcode = 0;}}else{printf("%s\n", gargv[1]);lastcode = 0;}}else{lastcode = 3;}return true;}return false;
}// 作为一个shell，获取环境变量应该从系统环境变量获取
// 今天外面做不到就直接从父进程shell中获取环境变量
void InitEnv()
{extern char **environ;int index = 0;while (environ[index]){genv[index] = (char *)malloc(strlen(environ[index]) + 1);strncpy(genv[index], environ[index], strlen(environ[index]));index++;}genv[index] = nullptr;
}int main()
{// 初始化环境变量表InitEnv();char command_buffer[basesize];while (true){// 打印命令行提示符PrintCommandLine();// 获取用户命令if (!GetCommandLine(command_buffer)){continue;}//printf("%s\n", command_buffer);//  分析命令ParseCommandLine(command_buffer, strlen(command_buffer));// 判断是不是内建命令if (CheckAndExecBuiltCommand()){continue;}// debug();// 执行命令ExecuteCommand();}return 0;
}

在模拟实现shell过程中，程序替换会不会影响重定向？

程序替换只是替换了代码数据，对进程PCB，文件描述符表，打开的文件都不会有影响，替换之前不会影响任何重定向的工作，

在上面重定向过程中打开的fd没有关闭，会不会有影响？
不会，当一个进程退出时，历史上所打开的文件会自动关闭，当一个进程退出，文件描述符表，就没必要存在，进程都释放了，文件描述符表自然也不需要存在，表里的内容就也会被释放不存在，对应指向的地址也不需要了，对应的文件大概率就也会被释放。

结论：文件描述符的生命周期，随进程！！！

一个进程打开一个只属于他自己的文件，只要进程打开了，最后进程退出了，这个文件描述符就会被释放掉，因为文件描述符表会被释放掉，如果这个文件是你一个打开的，只属于你一个人，那么这个文件也会被释放。

当我们申请内存时，并不是在物理内存上直接进行申请的，我们是先在虚拟地址空间上进行申请的，当我们要这个空间的时候，OS再给我们做写时拷贝，给我们再进行申请，申请的内存跟我们地址是强相关的，因为要进行页表映射，页表映射是通过地址进行的，一个进程关了，虚拟地址空间也没了，地址空间里面的堆区，栈区也没了，空间也被释放掉了，包括页表也会被释放掉，所以文件也一样，进程退了，文件描述符也没了，因为文件描述符表是属于进程的，所以，进程退出要释放PCB，虚拟地址空间，页表，文件描述符表，把OS创建的相关的数据结构全部free掉，所以与这些数据结构相关的内存，文件都会释放。

三.用户级缓冲区

解决上面问题，为什么不加fflush就刷新不出来呢？

1.用户级缓冲区介绍

前置知识：

在我们调用一下一些C语言接口的时候，并不是把数据直接拷贝到文件内核级缓冲区，把数据拷贝到内核，他的成本会很高，因为会调用系统调用，

调用系统调用也是有成本的(时间成本或空间成本)，减少系统调用次数，我们程序运行效率也就会越高。

在C++中学习STL里面，一次申请空间申请1.5-2倍，就可以保证当前申请完下次，下下次，或者更多，一定概率上就不用再进行申请内存，不再使用系统调用申请内存了，STL C++库底层一定是封装了系统调用，

调用函数实际上也是有成本的，C语言中的宏，C++中的内联函数，使用宏，内联函数，可以在目标地址处直接进行展开，在目标地址处直接进行展开，就没有函数调用的成本，就连自己写的函数，在语法设计上，别人都设计在效率角度上尽可能减少函数调用，跟何况今天要调用的是系统函数接口，系统函数在调用成本上，只会比我们自己函数更大，

所以我们把我们自己的字符串经write read等系统调用接口，拷贝到内核级缓冲区，拷贝成本是很大的！！！

所以要怎么做，将拷贝的效率变高呢？

所以在我们用户层，也要维护一个自己的用户级缓冲区，当我们在调用fputs，printf等接口时，我们的字符串并不是直接拷贝到内核级缓冲区内，而是先把数据先放到用户级缓冲区里，等他收集足够多的，字符串信息后，然后统一调用我们系统函数接口，从用户级缓冲区拷贝到内核级缓冲区，这样一次调用就能完成大量的数据拷贝工作。

用户级缓冲区为了减少调用系统函数次数，内核级缓冲区为了减少IO次数，本质上就是为了提高效率！！！！

用户级缓冲区在在哪呢？

之前我们提了一个FILE是一个结构体，里面封装了fd被我们证实了，【Linux】文件描述符fd上篇有讲，那么可不可以这个结构体里面也封装一个用户级缓冲区呢？如果里面定义了一个缓冲区，那么fprintf，fputs本质上是在干什么？就是把字符串拷贝到这个缓冲区里，所以这些函数的本质核心工作也是拷贝函数！！！只不过printf在拷贝前，做一下格式化，转成字符串，fwrite就直接写，这就是文本和二进制差别。

在用户级缓冲区就可以人为的进行控制缓冲区的刷新方案：

显示器文件：行刷新
普通文件：缓冲区写满再刷新，
不经过缓冲区，不用C语言接口，直接调用系统函数接口

从用户级缓冲区到内核级缓冲区，我们就认为发生了拷贝，用户把数据交给内核，就跟用户无关了

我们来看看FILE结构体：

2.解决上面问题，为什么不加fflush就刷新不出来呢？

有了上述知识铺垫，加fflush，就是把数据从用户级缓冲区刷新到内核级缓冲区，printf等一些C语言接口函数，把数据写到用户级缓冲区中，合适的时候再进行调用write等一些系统调用接口，也就是积累一部分数据后才进行调用刷新，而上面代码中直接关闭了文件，数据还在用用户级缓冲区内，想往内核进行刷新的时候，发现文件已经被关闭，没机会进行刷新，所以文件log1中没有数据。

看下面代码，可以使用fflush进行刷新：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{close(1);int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);fflush(stdout);close(fd1);return 0;
}

看下面代码，也可以不关闭文件，进行刷新，因为进程关闭前会检测缓冲区是否有内容，如果有内容就刷新：
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{close(1);int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);//fflush(stdout);// close(fd1);return 0;
}

看下面代码，也可以调用C语言接口fclose进行刷新，也会先刷新，再进行关闭，因为fclose底层进行了判断，如果缓冲区里面有内容就进行刷新，然后再关闭文件，等下可以看看后续模拟实现封装代码：
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>int main()
{close(1);int fd1 = open("log.txt1",O_WRONLY | O_CREAT | O_APPEND,0666);printf("fd1: %d\n",fd1);fclose(stdout);//fflush(stdout);// close(fd1);return 0;
}

总结：当一个进程退出的时候，会自动刷新缓冲区内容，包括stdin stdout stderr。exit也是一样退出前会刷新缓冲区，

我们对应的数据什么时候能从内核级缓冲区刷新到外设呢？

根本原则是由OS自主决定的，除非特殊情况，比如文件关闭，就自己刷新了。

那我们把数据从内核级缓冲区刷新到文件中，我们该怎么做呢？

OS给我们提供了对应的系统调用接口：

作用：把我们内核状态下的设备数据同步到存储设备上。

让我们再来看看下面代码：
#include <stdio.h>
#include <string.h>
#include <unistd.h>int main()
{//C库printf("hello printf\n");fprintf(stdout,"hello fprintf\n");const char *message = "hello fwrite\n";fwrite(message,1,strlen(message),stdout);//系统调用const char *w = "hello write\n";write(1,w,strlen(w));fork();return 0;
}
1.为什么调用C语言的接口，打印了两遍呢？

根据我们上面说的知识，现在我们就能很清楚的回答

因为重定向了，刷新方案，由行刷新变成缓冲区满了再刷新，走到fork的时候，数据还在用户级缓冲区中，函数掉完了并不能保证数据刷新到内核级缓冲区里，因为刷新方案改变，走到fork时，用户级缓冲区里还有三行内容，调用fork时，父子进程各自执行自己的fflush刷新，所以就有了两次打印数据，而系统调用不经过缓冲区，直接将数据进行写入到内核级缓冲区，不受fflush影响，因为已经在内核级缓冲区中了。

2.直接运行为什么都只打印一边呢？

因为因为默认是像显示器文件进行打印，是行刷新，当进行fork时，当前缓冲区内容早已经被刷新了。

3.模拟实现封装stdio.h中的fopen fwrite fclose fflush

通过模拟实现实现封装stdio.h，来感受FILE结构体中的缓冲区，通过代码，可以感受数据调用C语言库函数先进行写入用户级缓冲区，再进行根据刷新方案，进行刷新，建议敲敲下面代码：

my_stdio.h

#pragma once#define SIZE 1024enum
{FILE_NONE = 0,FILE_LINE = 1,FILE_FULL = 2,
};struct IO_FILE
{int flag;//刷新方式int fileno;//文件描述符char outbuffer[SIZE];int size;int capacity;
};typedef struct IO_FILE myFILE;myFILE *mfopen(const char *filename, const char *mode);int mfwrite(const void *ptr, int num, myFILE *stream);void mfflush(myFILE*stream);void mfclose(myFILE*stream);

my_stdio.c

#include "my_stdio.h"
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>myFILE *mfopen(const char *filename, const char *mode)
{int fd = -1; if (strcmp(mode, "r") == 0){fd = open(filename, O_RDONLY);}else if (strcmp(mode, "w") == 0){fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);}else if (strcmp(mode, "a") == 0){fd = open(filename,O_WRONLY | O_CREAT | O_APPEND,0666);}if(fd == -1) return NULL;myFILE *fp = (myFILE*)malloc(sizeof(myFILE));if(!fp){close(fd);return NULL;}fp->fileno = fd;fp->flag = FILE_LINE;fp->size = 0;fp->capacity = SIZE;return fp;
}void mfflush(myFILE *stream)
{if(stream->size > 0){//进行系统调用刷新,把数据从用户缓存区刷新到内核级缓冲区write(stream->fileno,stream->outbuffer,stream->size);//刷新完后清空stream->size = 0;}
}int mfwrite(const void *ptr, int num, myFILE *stream)
{//拷贝memcpy(stream->outbuffer+stream->size,ptr,num);stream->size+=num;//检测是否要刷新if(stream->flag == FILE_LINE && stream->size > 0 && stream->outbuffer[stream->size-1] == '\n'){mfflush(stream);}return num;
}void mfclose(myFILE *stream)
{if(stream->size>0){mfflush(stream);}close(stream->fileno);
}