【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);
    }
    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把数据刷新到文件，这个过程就叫做持久化！！！

标签：服务器 linux C++

本文转载自: https://blog.csdn.net/2302_80652761/article/details/144238264
版权归原作者 花糖纸木 所有，如有侵权，请联系我们删除。

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

一.文件内核级缓冲区

1.write写入具体操作

2.read读取具体操作

3.修改的具体操作

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

二.重定向

1.认识

2.操作

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

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

3.来看看输入重定向：

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

三.用户级缓冲区

1.用户级缓冲区介绍

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

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

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

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

发表评论

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

关于作者

overfit同步小助手

相关阅读

文章导航