深入理解 Linux 基础 IO：从 C 库到系统内核

在 Linux 系统编程中，IO（输入输出）是最基础也是最重要的部分之一。无论是读写磁盘文件、与终端交互，还是进行网络通信，本质上都是 IO 操作。很多开发者对 C 语言的fopen、fread等函数非常熟悉，但对其背后的系统调用、文件描述符、缓冲区等底层机制却知之甚少。本文将从最基础的概念开始，层层深入，带你全面理解 Linux 基础 IO 的底层原理。

一、重新认识 "文件"

在深入 IO 操作之前，我们需要先搞清楚一个最基本的问题：什么是文件？

1.1 狭义的文件

从狭义上讲，文件就是存储在磁盘上的数据集合。磁盘作为永久性存储介质，保证了文件数据在断电后不会丢失。同时，磁盘也是一种外设，既是输入设备（可以读取数据）也是输出设备（可以写入数据）。因此，所有对磁盘文件的操作，本质上都是对外设的输入输出操作。

这里有一个容易被忽略的细节：即使是一个 0KB 的空文件，也会占用磁盘空间。这是因为文件不仅仅包含内容，还包含属性（元数据），如文件名、大小、创建时间、权限等。所以，文件 = 属性 + 内容，所有的文件操作也自然分为两类：对内容的操作和对属性的操作。

1.2 广义的文件：Linux 下一切皆文件

Linux 最著名的哲学之一就是 "一切皆文件"。这意味着在 Linux 系统中，几乎所有的资源都被抽象成了文件的形式，包括：

传统的磁盘文件和目录
硬件设备（键盘、显示器、网卡、磁盘、打印机等）
进程间通信机制（管道、共享内存等）
网络套接字（socket）

这种抽象带来了巨大的好处：开发者只需要学习一套统一的文件操作 API（open、read、write、close等），就可以访问系统中几乎所有的资源。

1.3 系统角度的文件操作

从操作系统的角度来看，对文件的操作本质上是进程对文件的操作。磁盘是由操作系统统一管理的，任何应用程序都不能直接访问磁盘。因此，所有的文件读写操作最终都必须通过操作系统提供的系统调用接口来实现。

我们平时使用的 C 语言fopen、fread等函数，以及 C++ 的ifstream、ofstream等类，都只是对系统调用的封装，为开发者提供了更方便的上层接口。

二、回顾 C 标准库 IO 接口

C 标准库提供了一套完整的文件操作函数，这些函数被称为标准 IO（stdio），是我们最常使用的文件操作方式。

2.1 文件的打开与关闭

使用fopen函数打开文件，fclose函数关闭文件：

cpp 复制代码

#include <stdio.h>

int main() {
    // 以写方式打开文件，如果不存在则创建，如果存在则清空
    FILE *fp = fopen("myfile", "w");
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    
    // 文件操作...
    
    fclose(fp);
    return 0;
}

一个常见的问题：当我们使用相对路径打开文件时，文件会被创建在哪里？

答案是：在程序的当前工作目录下。操作系统是如何知道程序的当前工作目录的呢？我们可以通过/proc文件系统来查看进程的信息：

bash 复制代码

# 查找进程ID
ps ajx | grep myProc
# 查看进程详细信息
ls /proc/[进程ID] -l

在输出结果中，cwd符号链接指向的就是进程的当前工作目录，exe符号链接指向的是可执行文件的完整路径。

2.2 文件的读写

使用fwrite函数写入文件，fread函数读取文件：

写文件示例：

cpp 复制代码

#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("myfile", "w");
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    
    const char *msg = "hello world!\n";
    int count = 5;
    while (count--) {
        fwrite(msg, strlen(msg), 1, fp);
    }
    
    fclose(fp);
    return 0;
}

读文件示例：

cpp 复制代码

#include <stdio.h>
#include <string.h>

int main() {
    FILE *fp = fopen("myfile", "r");
    if (!fp) {
        printf("fopen error!\n");
        return 1;
    }
    
    char buf[1024];
    const char *msg = "hello world!\n";
    while (1) {
        ssize_t s = fread(buf, 1, strlen(msg), fp);
        if (s > 0) {
            buf[s] = '\0';
            printf("%s", buf);
        }
        if (feof(fp)) {
            break;
        }
    }
    
    fclose(fp);
    return 0;
}

我们可以稍作修改，实现一个简单的**cat**命令：

cpp 复制代码

#include <stdio.h>
#include <string.h>

int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: %s <filename>\n", argv[0]);
        return 1;
    }
    
    FILE *fp = fopen(argv[1], "r");
    if (!fp) {
        printf("fopen error!\n");
        return 2;
    }
    
    char buf[1024];
    while (1) {
        int s = fread(buf, 1, sizeof(buf), fp);
        if (s > 0) {
            buf[s] = '\0';
            printf("%s", buf);
        }
        if (feof(fp)) {
            break;
        }
    }
    
    fclose(fp);
    return 0;
}

2.3 标准输入输出流

C 标准库默认会为每个进程打开三个标准流：

stdin：标准输入流，对应键盘
stdout：标准输出流，对应显示器
stderr：标准错误流，对应显示器

这三个流的类型都是FILE*，和fopen返回的文件指针类型相同。我们可以直接使用它们进行输入输出操作：

cpp 复制代码

#include <stdio.h>
#include <string.h>

int main() {
    const char *msg = "hello fwrite\n";
    fwrite(msg, strlen(msg), 1, stdout); // 输出到标准输出
    printf("hello printf\n"); // 本质上也是输出到stdout
    fprintf(stdout, "hello fprintf\n"); // 格式化输出到stdout
    fprintf(stderr, "hello stderr\n"); // 输出到标准错误
    
    return 0;
}

2.4 文件打开方式

fopen函数的第二个参数指定了文件的打开方式，常用的有：

模式	含义
`r`	只读打开，文件必须存在
`r+`	读写打开，文件必须存在
`w`	只写打开，如果文件不存在则创建，如果存在则清空
`w+`	读写打开，如果文件不存在则创建，如果存在则清空
`a`	追加写打开，如果文件不存在则创建，写入内容会追加到文件末尾
`a+`	读和追加写打开，如果文件不存在则创建，读从文件开头开始，写总是追加到末尾

三、系统调用 IO 接口

C 标准库的 IO 函数虽然方便，但它们本质上是对操作系统提供的系统调用接口的封装。要深入理解 IO 底层，我们必须学习这些系统调用。

3.1 一种传递标志位的技巧

在学习系统调用之前，我们先了解一种在系统编程中非常常见的技巧：使用位运算传递多个标志位。

cpp 复制代码

#include <stdio.h>

#define ONE 0001   // 二进制：0000 0001
#define TWO 0002   // 二进制：0000 0010
#define THREE 0004 // 二进制：0000 0100

void func(int flags) {
    if (flags & ONE) printf("flags has ONE! ");
    if (flags & TWO) printf("flags has TWO! ");
    if (flags & THREE) printf("flags has THREE! ");
    printf("\n");
}

int main() {
    func(ONE);                // 输出：flags has ONE!
    func(THREE);              // 输出：flags has THREE!
    func(ONE | TWO);          // 输出：flags has ONE! flags has TWO!
    func(ONE | TWO | THREE);  // 输出：flags has ONE! flags has TWO! flags has THREE!
    return 0;
}

这种技巧的核心是：每个标志位只占用二进制中的一位，通过 "按位或" 运算可以组合多个标志位，通过 "按位与" 运算可以检查某个标志位是否被设置。在系统调用open函数中，我们会大量使用这种技巧。

3.2 open 系统调用

open函数用于打开或创建一个文件，它有两个原型：

cpp 复制代码

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

参数说明：

pathname：要打开或创建的文件路径
flags：打开方式标志位，可以通过 "按位或" 组合多个选项
mode：当创建新文件时，指定文件的访问权限（如0644）

常用的 flags 选项：

O_RDONLY：只读打开
O_WRONLY：只写打开
O_RDWR：读写打开（这三个选项必须指定一个且只能指定一个）
O_CREAT：如果文件不存在则创建它，此时必须提供mode参数
O_TRUNC：如果文件存在且以写方式打开，则将其长度截断为 0
O_APPEND：以追加方式打开，写入内容会追加到文件末尾

返回值：

成功：返回一个非负整数，称为文件描述符（file descriptor）
失败：返回 - 1，并设置errno

3.3 write、read 和 close 系统调用

write函数用于向文件写入数据：
cpp 复制代码
```
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
```
从buf指向的缓冲区写入count个字节到文件描述符fd指向的文件，返回实际写入的字节数。
read函数用于从文件读取数据：
cpp 复制代码
```
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
```
从文件描述符fd指向的文件读取count个字节到buf指向的缓冲区，返回实际读取的字节数。
close函数用于关闭一个打开的文件描述符：
cpp 复制代码
```
#include <unistd.h>
int close(int fd);
```

使用系统调用写文件示例：

cpp 复制代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    umask(0); // 设置文件创建掩码为0，确保权限设置生效
    int fd = open("myfile", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open"); // 打印错误信息
        return 1;
    }
    
    int count = 5;
    const char *msg = "hello bit!\n";
    int len = strlen(msg);
    while (count--) {
        write(fd, msg, len);
    }
    
    close(fd);
    return 0;
}

使用系统调用读文件示例：

cpp 复制代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd = open("myfile", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    
    char buf[1024];
    while (1) {
        ssize_t s = read(fd, buf, sizeof(buf) - 1);
        if (s > 0) {
            buf[s] = '\0';
            printf("%s", buf);
        } else if (s == 0) {
            // 读到文件末尾
            break;
        } else {
            // 读取出错
            perror("read");
            break;
        }
    }
    
    close(fd);
    return 0;
}

四、文件描述符（fd）

open函数返回的文件描述符是理解 Linux IO 的核心概念之一。

4.1 什么是文件描述符

文件描述符是一个非负整数，它是进程访问打开文件的 "索引"。当我们打开一个文件时，操作系统会在内存中创建相应的数据结构来描述这个文件，然后给进程返回一个文件描述符，进程通过这个描述符来操作文件。

Linux 进程默认会打开三个文件描述符：

0：标准输入（stdin），对应键盘
1：标准输出（stdout），对应显示器
2：标准错误（stderr），对应显示器

我们可以直接使用这三个描述符进行输入输出：

cpp 复制代码

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    char buf[1024];
    // 从标准输入读取数据
    ssize_t s = read(0, buf, sizeof(buf) - 1);
    if (s > 0) {
        buf[s] = '\0';
        // 写入标准输出
        write(1, buf, strlen(buf));
        // 写入标准错误
        write(2, buf, strlen(buf));
    }
    return 0;
}

4.2 文件描述符的底层原理

要理解文件描述符的工作原理，我们需要了解内核中的三个关键数据结构：

task_struct：描述进程的结构体，每个进程都有一个
files_struct ：描述进程打开的文件的结构体，task_struct中有一个指针指向它
file ：描述一个打开的文件的结构体，每个打开的文件在内核中都有一个file结构体

files_struct中最重要的部分是一个指针数组，称为文件描述符表。文件描述符就是这个数组的下标，数组中的每个元素都是一个指向file结构体的指针。

这个关系可以用下图表示：

4.3 文件描述符的分配规则

文件描述符的分配遵循一个简单的规则：在文件描述符表中，找到当前未被使用的最小下标，作为新的文件描述符。

我们可以通过代码验证这一点：

cpp 复制代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 关闭标准输入
    close(0);
    
    int fd = open("myfile", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    
    printf("fd: %d\n", fd); // 输出：fd: 0
    close(fd);
    return 0;
}

在这个例子中，我们先关闭了文件描述符 0，然后打开一个新文件，新文件的描述符就是 0。

五、重定向的本质

有了文件描述符的知识，我们就可以理解重定向的本质了。

5.1 什么是重定向

重定向就是改变输入输出的默认方向。比如，本来应该输出到显示器的内容，输出到了文件中；本来应该从键盘读取的输入，从文件中读取。

常见的重定向符号有：

>：输出重定向（覆盖）
>>：输出重定向（追加）
<：输入重定向

5.2 重定向的底层原理

重定向的本质就是改变文件描述符表中对应下标的指向。

我们来看一个简单的例子：

cpp 复制代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    // 关闭标准输出（文件描述符1）
    close(1);
    
    // 打开一个文件，根据文件描述符分配规则，新文件的描述符会是1
    int fd = open("myfile", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    
    // 本来应该输出到显示器的内容，现在输出到了myfile中
    printf("fd: %d\n", fd);
    fflush(stdout); // 刷新缓冲区
    
    close(fd);
    exit(0);
}

运行这个程序后，我们会发现屏幕上没有任何输出，而myfile文件中却有内容fd: 1。这是因为printf函数本质上是向stdout输出，而stdout底层对应的是文件描述符 1。当我们把文件描述符 1 指向了myfile后，所有向标准输出的内容都会写入到myfile中。

5.3 使用 dup2 系统调用实现重定向

虽然我们可以通过先关闭再打开的方式实现重定向，但这种方式不够灵活。Linux 提供了dup2系统调用，可以更方便地实现重定向：

cpp 复制代码

#include <unistd.h>
int dup2(int oldfd, int newfd);

dup2函数的作用是将newfd复制为oldfd。也就是说，执行dup2(oldfd, newfd)后，newfd会指向oldfd指向的文件。如果newfd已经打开，会先关闭它。

使用 dup2 实现输出重定向：

cpp 复制代码

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd = open("log.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    
    // 将标准输出（1）重定向到fd指向的文件
    dup2(fd, 1);
    
    // 现在printf的内容会输出到log.txt中
    printf("hello world!\n");
    fflush(stdout);
    
    close(fd);
    return 0;
}

六、深入理解 IO 缓冲区

缓冲区是 IO 系统中最容易被忽视但又至关重要的组成部分。很多看似奇怪的 IO 行为，本质上都是缓冲区机制在起作用。理解缓冲区的原理，不仅能帮助我们写出更高效的代码，还能避免很多难以调试的 IO 陷阱。

6.1 什么是缓冲区

缓冲区本质上是内存空间的一部分。操作系统或标准库会在内存中预留一块特定的存储空间，用来临时存放输入或输出的数据，这块预留的空间就叫做缓冲区。

根据数据流向的不同，缓冲区可以分为两类：

输入缓冲区：用于临时存放从输入设备（如键盘、磁盘）读取的数据
输出缓冲区：用于临时存放将要写入输出设备（如显示器、磁盘、打印机）的数据

6.2 为什么需要缓冲区机制

如果没有缓冲区，我们每次进行 IO 操作都必须直接调用系统接口访问硬件设备，这会带来两个严重的性能问题：

1. 频繁的系统调用开销

每次调用read或write系统调用，CPU 都需要从用户态切换到内核态，执行完内核代码后再切换回用户态。这种上下文切换的开销非常大，尤其是在进行大量小数据量 IO 操作时。

例如，如果我们要向磁盘写入 1000 个字节，没有缓冲区的情况下需要调用 1000 次write系统调用，也就意味着要进行 2000 次 CPU 状态切换。而有了缓冲区后，我们可以把这 1000 个字节先攒起来，一次性写入磁盘，只需要 1 次系统调用和 2 次状态切换。

2. 硬件设备速度不匹配

计算机中不同硬件设备的速度差异巨大：CPU 的速度是纳秒级的，内存是微秒级的，而磁盘是毫秒级的。磁盘的读写速度比 CPU 慢了上百万倍。

如果没有缓冲区，CPU 每次写入一个字节都要等待磁盘完成写入操作才能继续执行，这会导致 CPU 大部分时间都处于空闲等待状态，资源利用率极低。

缓冲区的引入完美解决了这个问题：

对于写操作：CPU 可以一次性把大量数据写入内存中的缓冲区，然后立刻去执行其他任务，由操作系统在合适的时机把缓冲区的数据批量写入磁盘
对于读操作：操作系统可以一次性从磁盘读取比请求更多的数据到缓冲区，后续的读操作可以直接从内存中获取数据，速度提升上千倍

一个非常直观的例子是打印机打印文档：我们把文档发送给打印机后，立刻就可以继续使用电脑做其他事情，不需要等待打印完成。这就是因为文档先被写入了打印机的缓冲区，由打印机自己慢慢打印。

6.3 标准 IO 的三种缓冲类型

C 标准库（glibc）的标准 IO 函数（printf、fwrite等）在系统调用之上实现了自己的用户态缓冲区，并根据不同的使用场景提供了三种缓冲策略：

1. 全缓冲区（Full Buffering）

特点：只有当缓冲区被完全填满后，才会执行实际的 IO 系统调用
适用场景：磁盘文件的读写操作默认使用全缓冲
缓冲区大小：通常为 4KB 或 8KB（取决于系统和文件系统）

2. 行缓冲区（Line Buffering）

特点：当在输入或输出中遇到换行符\n时，才会执行 IO 系统调用。如果缓冲区被填满但还没有遇到换行符，也会执行系统调用
适用场景 ：终端设备的输入输出（标准输入stdin和标准输出stdout）默认使用行缓冲
缓冲区大小：通常为 1024 字节

3. 无缓冲区（Unbuffered）

特点：不进行任何缓冲，每次调用 IO 函数都会立即执行系统调用
适用场景 ：标准错误流stderr默认使用无缓冲，目的是让错误信息能够立即显示出来，便于程序调试和问题排查

缓冲区的刷新条件

除了上述默认的刷新机制外，以下几种情况也会触发缓冲区的刷新：

缓冲区被填满时（全缓冲和行缓冲）
显式调用fflush函数强制刷新
进程正常退出时（会自动刷新所有打开的流的缓冲区）
调用fclose关闭文件时

6.4 缓冲区机制的常见陷阱

缓冲区的存在虽然提高了 IO 效率，但也带来了一些容易被忽视的问题。下面通过几个经典的例子来理解这些陷阱。

陷阱 1：重定向后 printf 不输出

我们先来看一段代码：

cpp 复制代码

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 关闭标准输出（文件描述符1）
    close(1);
    
    // 打开一个文件，根据文件描述符分配规则，新文件的描述符会是1
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0) {
        perror("open");
        return 0;
    }
    
    // 向标准输出写入内容
    printf("hello world: %d\n", fd);
    
    // 关闭文件
    close(fd);
    return 0;
}

按照我们之前对重定向的理解，这段代码应该会把hello world: 1写入到log.txt文件中。但实际运行后，我们会发现log.txt文件是空的！

问题分析： 当stdout指向终端时，它使用的是行缓冲模式。我们在printf中使用了换行符\n，所以会立即刷新缓冲区，内容会显示在屏幕上。

但当我们把stdout重定向到磁盘文件后，标准库会自动将缓冲模式从行缓冲 切换为全缓冲 。我们写入的 "hello world: 1\n" 只有十几个字节，远远没有填满 4KB 的缓冲区，所以不会触发自动刷新。而我们在close(fd)之前没有显式刷新缓冲区，导致缓冲区中的数据在进程退出时丢失了。

解决方案： 在close(fd)之前调用fflush(stdout)强制刷新缓冲区：

cpp 复制代码

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    close(1);
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0) {
        perror("open");
        return 0;
    }
    
    printf("hello world: %d\n", fd);
    fflush(stdout); // 强制刷新标准输出缓冲区
    
    close(fd);
    return 0;
}

陷阱 2：stderr 无缓冲的验证

我们可以通过另一个例子来验证stderr是无缓冲的：

cpp 复制代码

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 关闭标准错误（文件描述符2）
    close(2);
    
    // 打开一个文件，新文件的描述符会是2
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0) {
        perror("open");
        return 0;
    }
    
    // 向标准错误输出内容
    perror("hello world");
    
    close(fd);
    return 0;
}

运行这段代码后，我们会发现log.txt文件中成功写入了内容：

bash 复制代码

hello world: Success

这是因为stderr默认是无缓冲的，每次输出都会立即执行系统调用，不需要等待缓冲区填满或遇到换行符。

6.5 FILE 结构体与缓冲区的本质

我们已经知道，C 标准库的 IO 函数是对系统调用的封装。那么，标准库的缓冲区是在哪里维护的呢？答案就在FILE结构体中。

FILE 结构体的定义

FILE是struct _IO_FILE的别名，定义在/usr/include/stdio.h中，而struct _IO_FILE的具体定义在/usr/include/libio.h中：

cpp 复制代码

struct _IO_FILE {
    int _flags;           /* 标志位，包括IO模式和缓冲类型 */
#define _IO_file_flags _flags

    // 缓冲区相关指针
    char* _IO_read_ptr;   /* 当前读指针 */
    char* _IO_read_end;   /* 读缓冲区结束位置 */
    char* _IO_read_base;  /* 读缓冲区起始位置 */
    char* _IO_write_base; /* 写缓冲区起始位置 */
    char* _IO_write_ptr;  /* 当前写指针 */
    char* _IO_write_end;  /* 写缓冲区结束位置 */
    char* _IO_buf_base;   /* 缓冲区起始位置 */
    char* _IO_buf_end;    /* 缓冲区结束位置 */

    // 其他用于支持回退和撤销操作的指针
    char *_IO_save_base;
    char *_IO_backup_base;
    char *_IO_save_end;

    struct _IO_marker *_markers;
    struct _IO_FILE *_chain; /* 所有打开的FILE结构体形成一个链表 */

    int _fileno;           /* 封装的文件描述符！这是连接系统调用的关键 */

#if 0
    int _blksize;
#else
    int _flags2;
#endif

    _IO_off_t _old_offset; /* 旧的文件偏移量 */

    unsigned short _cur_column;
    signed char _vtable_offset;
    char _shortbuf[1];     /* 用于无缓冲模式的单字节缓冲区 */

    _IO_lock_t *_lock;     /* 线程安全锁 */
#ifdef _IO_USE_OLD_IO_FILE
};

从这个结构体可以清晰地看到：

FILE结构体内部封装了文件描述符_fileno，这是所有 IO 操作最终要使用的
FILE结构体维护了一整套用户态缓冲区，通过一系列指针来管理缓冲区的读写位置
FILE结构体还包含了缓冲类型、文件偏移量、锁等信息

这就解释了为什么我们说：标准 IO 函数是在系统调用之上的一层封装，它在用户态提供了缓冲区机制，以减少系统调用的次数。

经典面试题：fork 与缓冲区

下面这个例子是 Linux 系统编程中最经典的面试题之一，几乎所有面试官都会用它来考察候选人对缓冲区和 fork 的理解：

cpp 复制代码

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main() {
    const char *msg0 = "hello printf\n";
    const char *msg1 = "hello fwrite\n";
    const char *msg2 = "hello write\n";
    
    printf("%s", msg0);
    fwrite(msg1, strlen(msg1), 1, stdout);
    write(1, msg2, strlen(msg2));
    
    fork();
    
    return 0;
}

问题： 这段代码分别在终端直接运行和重定向到文件运行时，输出结果有什么不同？为什么？

答案：

直接在终端运行：
bash 复制代码
```
hello printf
hello fwrite
hello write
```
输出三行内容，和我们预期的一样。
重定向到文件运行（./a.out > file）：
bash 复制代码
```
hello write
hello printf
hello fwrite
hello printf
hello fwrite
```
输出五行内容！printf和fwrite的内容各出现了两次，而write的内容只出现了一次。

详细分析： 这个现象的根本原因是缓冲区的存在 和fork 的写时拷贝机制共同作用的结果。

情况 1：直接在终端运行

stdout指向终端，使用行缓冲模式
printf和fwrite的内容都包含换行符\n，所以会立即刷新缓冲区，内容被写入终端
write是系统调用，没有缓冲区，直接写入终端
此时缓冲区中没有残留数据
执行fork后，子进程复制了父进程的地址空间，但缓冲区是空的
父子进程退出时，没有数据需要刷新，所以最终只输出三行

情况 2：重定向到文件运行

stdout指向磁盘文件，使用全缓冲模式
printf和fwrite的内容虽然包含换行符，但不会触发缓冲区刷新（全缓冲只有缓冲区满才会刷新）
这两行内容被存放在stdout的用户态缓冲区中
write是系统调用，没有缓冲区，直接写入文件
执行fork时，父进程的地址空间被复制给子进程，包括stdout缓冲区中的内容
父子进程各自拥有一份缓冲区的拷贝
当父子进程退出时，会各自刷新自己的缓冲区，将内容写入文件
所以printf和fwrite的内容各被写入了两次，而write的内容只被写入了一次

这个例子清晰地证明了：

printf和fwrite等标准 IO 函数有用户态缓冲区
write等系统调用没有用户态缓冲区
缓冲区是由C 标准库提供的，而不是操作系统内核

6.6 用户态缓冲区与内核态缓冲区

需要特别注意的是，我们上面讨论的缓冲区都是用户态缓冲区，由 C 标准库在进程地址空间中维护。

实际上，操作系统内核也会维护自己的内核态缓冲区 （也叫页高速缓存 Page Cache）。当我们调用write系统调用时，数据并不是直接写入磁盘，而是先写入内核的页高速缓存，然后由操作系统在合适的时机（如缓冲区满、定时刷新、调用fsync等）将数据批量写入磁盘。

这样就形成了一个两级缓冲的架构：

复制代码

应用程序 <-> 用户态缓冲区（glibc） <-> 内核态缓冲区（Page Cache） <-> 磁盘

这种两级缓冲机制进一步提高了 IO 效率，但也带来了数据丢失的风险。如果系统突然断电，内核缓冲区中还没有写入磁盘的数据就会丢失。为了确保数据的持久性，我们可以使用fsync系统调用强制将内核缓冲区中的数据刷新到磁盘。