一.文件内核级缓冲区
在一个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); } 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); }
加餐知识：
把数据 从应用层写到OS内，然后再调用fsync把数据刷新到文件，这个过程就叫做持久化！！！
版权归原作者 花糖纸木 所有， 如有侵权，请联系我们删除。