用户缓冲区

1. 引入问题

// 输出信息带换行，调用完后close(1)
int main()    
{    
    const char* s1 = "this is fwrite\n";                                                                         
    const char* s2 = "this is write\n";    
    printf("this is printf\n");    
    fprintf(stdout, "this is fprintf\n");    
    fwrite(s1, strlen(s1), 1, stdout);    
    write(1, s2, strlen(s2));    
    close(1);    
    return 0;    
}

在这里插入图片描述

// 输出信息不带换行，调用完后close(1)
int main()    
{    
    const char* s1 = "this is fwrite";                                                                         
    const char* s2 = "this is write";    
    printf("this is printf");    
    fprintf(stdout, "this is fprintf");    
    fwrite(s1, strlen(s1), 1, stdout);    
    write(1, s2, strlen(s2));   
    close(1);    
    return 0;    
}

在这里插入图片描述

// 输出信息不带换行，没有close(1)
int main()    
{    
    const char* s1 = "this is fwrite";                                                                         
    const char* s2 = "this is write";    
    printf("this is printf");    
    fprintf(stdout, "this is fprintf");    
    fwrite(s1, strlen(s1), 1, stdout);    
    write(1, s2, strlen(s2));    
    return 0;    
}

在这里插入图片描述

现象：printf，fprintf，fwrite 这三个都是 C 库函数，write 是系统调用。当输出信息去掉 \n，调用语言级别的函数后 close(1) 关闭标准输出，三个函数内的输出信息不会被打印在屏幕上（输出信息有 \n 就正常打印），但是作为系统调用的 write 却依旧正常打印。

为什么最后没有调用 close(1) 就正常打印了？
而为什么调用了 close(1) ，printf，fprintf，fwrite 就不打印了呢？close(1) 不是在 printf 之后才关闭的吗？
又为什么 write() 不受影响？？

2. 用户缓冲区

2.1 解答上述问题

讲文件描述符的时候，我们认识了系统调用 write()，并且我们知道，C 中的诸如 printf，fprintf，fwrite 这样的打印函数，底层一定是调用的 write，。

当我们不调用 close(1)，即便输出信息没有换行符，它是可以正常写入到显示器的，这是毋庸置疑的，所以问题肯定出在 close(1) 这里。而事实也确实是，在 close 之前，输出信息确实输出了，只不过是写入到缓冲区了，并没有写入到显示器上。

需要注意的是，这个缓冲区一定不在操作系统内，它不是系统级别的缓冲区。如果这个缓冲区在内核中的话，那么 close 关闭文件描述符时，就一定会把缓冲区的内容刷新到显示器上。所以可以证明 C 语言各种输出打印函数，它写入的这个缓冲区不是系统级别的缓冲区。

而 write 作为系统调用，自然是往内核中的缓冲区写入，所以当 close(1) 时，内核缓冲区刷新到显示器，信息正常打印。如果这样说明，那就势必会有另一个问题：

你之前不是还说 printf，fprintf，fwrite 这样的函数，最终都是要调用 write 的吗？现在不是刚说调用 write 的话，就往内核的缓冲区中写入，那最终不还是会刷新到显示器上，那我为啥没看到信息

其实不然，语言级别的函数并不会一上来就直接调 write 系统调用去做写入操作，而是先把输出信息写入到自己语言级别的缓冲区上（你没听错，C 也有自己的缓冲区），而这种缓冲区称为用户缓冲区， 根据 C 自己的刷新策略，再决定要不要调用 write 系统调用，将缓冲区的数据通过 write 写入到内核的缓冲区中，再进而刷新到外设上。

上述代码的三个语言库函数，它们先把内容写入到用户缓冲区（不带换行符)，然后进程退出时，本应该将缓冲区的内容刷新出去，但却发现调用完几个 C 式接口后，1号文件描述符被关闭了，该进程的文件描述符表中的下标为1的位置处的指针就不再指向显示器文件了，因此也就无法调用 write() 向显示器写入。这就是为什么语言层面上的三个输出函数，最终没能将数据打印到显示器上。简言之，就是库函数中的输出信息，并不会第一时间交给操作系统，而是先仍到自己语言的缓冲区，这样一来，当指向显示器文件的文件描述符被关闭，那么在语言层面上，缓冲区的内容就再也无法刷新到显示器上。

而为什么输出信息带上 \n 的时候，即便调用完后 close(1)，这些内容也依旧可以正常写入到显示器，是因为显示器文件的刷新策略就是行刷新，所以在诸如 printf 将内容写入到用户缓冲区，发现内容中有 \n，就立即调用 write() 系统调用将数据进行刷新，而用户缓冲区刷新的本质，就是将数据通过1号文件描述符 + write() 写入到内核缓冲区中。

曾经在讲进程的创建、终止的时候，我们做过一个实验，exit 退出进程时，信息正常打印，但是系统调用 _exit 退出时，一个信息也不打，现在我们就应该要清楚，并不是 _exit 不想做这件事，而是它做不到！调用 printf 打印输出，内容是写入到 C 自己的缓冲区， _exit 是系统函数，它可无法看到上层的用户缓冲区，更别提对上层用户缓冲区的内容做刷新了。那 exit 为什么能刷新，那不就是因为它也是 C 式接口吗，进程退出时，调一下 write + fd=1 的方式，将自己的缓冲区内容刷新到内核中不就行了吗？！包括 C 中的强制刷新 fflush 这样的函数，底层都是通过调 write 系统调用实现的。

2.2 缓冲区刷新策略

关于缓冲区是根据什么策略刷新的，我们只需要关注上层，即用户缓冲区即可。内核缓冲区是操作系统内部的事情，不需要我们关心，怎么刷新，用户无法控制，因为用户无法访问系统内核。

用户缓冲区刷新策略：

无缓冲：直接刷新，即写即刷
行缓冲：直到碰到 \n 才刷新，即不换行不刷新（显示器默认刷新策略，根据用户的阅读习惯决定的）
全缓冲：累计到缓冲区空间满了才进行刷新（文件写入一般都采用全缓冲，因为文件写入一般不会立马查看）
不管什么情况，进程退出时，缓冲区都强制刷新

缓冲区的作用：

解决用户的效率问题。
就好比快递行业，如果没有快递公司帮助用户运输快递，假设今天我有一个很重要的文件需要给远在天边的客户，那我就得自己坐飞机、坐高铁跑过去，有了快递运输，我可以直接上一个某丰寄过去就行了。这就是解决了我（用户）办事的效率。但是这并不解决原来该有的时间问题，你交给快递公司运输，快递公司还是需要时间，只不过是快递公司帮你做了这件事，因此提高的只是用户的效率问题，底层该怎么做还是怎么做。

快递公司也总不能我寄一个快递，就给我送一个快递吧。那一个小区、一个学校一天多少人寄快递，快递公司不得跑成百上千趟，亏到裤衩子都得卖了。所以快递行业也是一个现实版缓冲区的写照。

所以缓冲区是如何提高用户效率的呢？？ ---- 当我在 C 中调用诸如 printf，fprint，fwrite 等接口时，都是先将信息丢到缓冲区，然后函数就直接返回了，返回之后直接执行后续代码，这样在用户层，调用 C 语言接口的速度变快，用户效率就得到了提高；如果没有缓冲区，那么用户每调一次 printf，fprint，fwrite 等接口时，C 语言就调一次 write 将数据刷新出去，这样效率就被拉低了。

上述的行缓冲，就相当于当天的寄件当天发（默认的）；全缓冲则是等到我的驿站装不下了，再一次性发出去；无缓冲可以理解为 “八百里加急”。
配合格式化。
write 可是一个只能接收字符串输入的系统调用，在我们键盘输入的 123 或者显示器打印的 123，这些在操作系统看来都是字符串！而诸如 printf 格式化输出，就是在整合输出信息，将输出信息转换为字符串，再写入自己的缓冲区中，进而写入内核。调用 a = 1; printf("this is %d", a) 写入用户缓冲区的信息，最终都会被解释为： this is 1 。

那这个 C 语言提供的缓冲区具体在哪里呢？？
谈论缓冲区就离不开文件操作，在 C 中，任何文件操作都离不开 FILE，FILE 就是封装了一个 struct，其结构体内又封装了 fd 文件描述符这样的字段，还有打开文件的缓冲区字段和相关维护信息。简言之，缓冲区就在 FILE 这个结构体内。

所以当执行 fprintf(stdout, "this is write ope\n"); 无非就是将输出信息拷贝到 stdout，stdout 是一个 FILE 结构体，里面有缓冲区，再检查是否有 \n 或者缓冲区是否满了，然后调用 write 刷新到外设。这也是为什么我们在 C 中 fopen 得到的返回值 FILE*，后续任何文件操作都不离开这个 FILE*。

而假设在 C 内一次性打开10个文件，那就会有10个缓冲区，每个文件都会有自己的缓冲区，因此每个文件也都才能有自己的文件描述符。每一个文件都配置一个语言层缓冲区，再通过文件描述符把缓冲区内容刷新到外设。

3. 全缓冲案例

int main()
{
    const char* s1 = "this is fwrite\n";
    const char* s2 = "this is write\n";
    printf("this is printf\n");
    fprintf(stdout, "this is fprintf\n");
    fwrite(s1, strlen(s1), 1, stdout);
    write(1, s2, strlen(s2));
    sleep(10);
    return 0;
}

在这里插入图片描述

现象：重定向到文件输出，除了 write 系统调用会立即写入文件，C 式接口都不没有将信息写入到文件中。

这是因为当我们运行的同时，做重定向把信息写入到文件中，缓冲区的刷新策略就变为了全缓冲（那么即便输出信息带有换行符，也不刷新）。作为用户，第一观察的是显示器，所以显示器才以行缓冲作为刷新策略，而用户第一时间并不会查看文件，文件所承担的更多职责是存储数据，而非拿来看的。因此涉及到文件写入操作，缓冲区的刷新策略都是全缓冲（为了提高效率）。

而代码中那几条输出信息，不足以写满缓冲区，所以只有当进程退出了，缓冲区的数据才会被刷新写入到文件中。我们也确实看到了，一开始只有 write 输出的信息，并没有 C 式接口的信息，这也是因为 write 是系统调用，它直接就可以写入到内核级别的缓冲区，而文件写入，改变缓冲区的刷新策略，变的是用户级别的缓冲区，跟内核没有关系，因此 write 该写入还是正常写入。而几条 C 式接口的信息虽然也写入了，但是停留在缓冲区中不被刷新。

// 最后 frok() 创建子进程
int main()
{
    const char* s1 = "this is fwrite\n";
    const char* s2 = "this is write\n";
    printf("this is printf\n");
    fprintf(stdout, "this is fprintf\n");
    fwrite(s1, strlen(s1), 1, stdout);
    write(1, s2, strlen(s2));
    fork();
    return 0;
}

在这里插入图片描述

现象：正常运行的话，信息正常写入到显示器，但是当运行时做了重定向，运行结果就显得非常奇怪，只有 write 这个系统调用输出了一次，其它 C 式接口都输出了两次，这是为什么呢？？

这其实是 fork 导致的现象，执行 fork()，操作系统创建子进程，当父子进程一方有写入数据的操作时，那么会发生写时拷贝。而语言是属于用户层的，所以语言中提供的缓冲区，自然也是用户级别的缓冲区，其本质就是在进程地址空间中堆区 malloc 出来的一段内存空间而已。

而进程退出之前，就已经 fork 了，代表着进程退出之前就已经有子进程了。此时进程退出，需要刷新缓冲区，刷新的本质就是将缓冲区的内容全部写入到内核中，是一种清空的行为，而清空也算是写入操作的一种！既然是写入，那就必须要发生写时拷贝问题，因此父子进程各自有一份缓冲区数据。进程退出时，父子进程都要对自己的缓冲区做刷新操作，所以 C 式接口的信息输出了两次。

所以造成这个现象的原因为以下几点：