【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";
// 讲获取的当前路径输入到pwdenv
snprintf(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/xxx
size_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 hello
if (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 1024

enum
{
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);

————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/2302_80652761/article/details/144238264