C
Linux 系统编程：深入理解一切皆文件与缓冲区原理及实战封装
Linux 系统编程中一切皆文件通过统一文件模型屏蔽硬件差异，利用 task_struct、file、file_operations 结构体实现资源抽象。缓冲区协调 CPU 与外设速度差异，分为全缓冲、行缓冲和无缓冲三种类型，影响 IO 效率。文章通过内核源码解析、标准库函数验证及 fork 场景演示，深入剖析缓冲区刷新机制，并手动封装简易 IO 库模拟 Glibc 核心功能，帮助开发者掌握底层 IO 原理。
Linux 系统编程中一切皆文件通过统一文件模型屏蔽硬件差异，利用 task_struct、file、file_operations 结构体实现资源抽象。缓冲区协调 CPU 与外设速度差异，分为全缓冲、行缓冲和无缓冲三种类型，影响 IO 效率。文章通过内核源码解析、标准库函数验证及 fork 场景演示，深入剖析缓冲区刷新机制，并手动封装简易 IO 库模拟 Glibc 核心功能，帮助开发者掌握底层 IO 原理。
在 Linux 系统编程中，'一切皆文件'和'缓冲区'是两个贯穿始终的核心概念。前者构建了 Linux 系统资源访问的统一模型，让键盘、显示器、网卡等设备都能通过文件接口操作；后者则是提升 IO 效率的关键，协调了高速 CPU 与低速外设的性能差异。
很多开发者在使用文件 IO 时，只知道调用 fopen、write 等接口，却不理解'为什么键盘能当文件读''为什么 printf 需要 fflush 才能确保输出'。本文将从底层原理出发，深入拆解'一切皆文件'的实现机制和缓冲区的核心逻辑，带你从'会用'升级到'懂原理'，甚至能手动封装一个简易的 IO 库。
提到 Linux 的'一切皆文件'，很多人会把它当作一句抽象的设计哲学。但实际上，这是一套严谨的技术实现——通过统一的文件模型，将磁盘文件、硬件设备、进程、管道等所有系统资源，都抽象为'文件'，并提供一套标准的 IO 接口（open、read、write、close）进行操作。
'一切皆文件'的设计带来了一个巨大的好处：开发者只需掌握一套 IO 接口，就能操作系统中的绝大部分资源。比如：
读取磁盘文件内容，用 read；从键盘获取输入，用 read；向显示器输出内容，用 write；给网络套接字发送数据，用 write；查看进程状态（/proc/[pid]/status），本质也是读取'进程文件'。
举个直观的例子，我们可以用同样的 cat 命令查看磁盘文件和系统信息：
# 查看磁盘文件
cat test.txt
# 查看 CPU 信息（/proc/cpuinfo 是内核动态生成的虚拟文件）
cat /proc/cpuinfo
# 查看内存使用情况
cat /proc/meminfo
这三个操作的底层都调用了read系统调用，但访问的资源完全不同——磁盘、CPU、内存。这就是'一切皆文件'的魅力：屏蔽了不同资源的底层差异，提供了统一的访问方式。
'一切皆文件'的实现，核心依赖内核中的三个关键结构体：task_struct（进程控制块）、file（文件元数据）、file_operations（文件操作函数集合）。它们的关系是：进程通过文件描述符找到 file 结构体，file 结构体通过 file_operations 找到对应资源的具体操作方法。
我们以 Linux 内核 3.10 版本为例（可通过 uname -a 查看内核版本），三个结构体的定义位置如下：
task_struct（进程控制块）：
/usr/src/kernels/3.10.0-1160.71.1.el7.x86_64/include/linux/sched.hfile（文件元数据）：/usr/src/kernels/3.10.0-1160.71.1.el7.x86_64/include/linux/fs.hfile_operations（文件操作集合）：/usr/src/kernels/3.10.0-1160.71.1.el7.x86_64/include/linux/fs.h
file 结构体存储了一个打开文件的核心信息，无论是磁盘文件还是键盘设备，一旦被打开，内核都会创建一个 file 结构体：
struct file {
// 指向文件操作函数集合的指针（核心）
const struct file_operations *f_op;
// 文件当前读写位置
loff_t f_pos;
// 文件引用计数（多个进程可共享一个 file 结构体）
atomic_long_t f_count;
// 文件打开标志（如 O_RDONLY、O_APPEND）
unsigned int f_flags;
// 文件访问模式（只读、只写、读写）
fmode_t f_mode;
// 关联的 inode 节点（存储文件的磁盘属性）
struct inode *f_inode;
// 其他成员省略...
};
其中最核心的是f_op指针，它指向file_operations结构体——这个结构体是'一切皆文件'的关键，封装了该文件的所有操作方法。
file_operations 是一个函数指针集合，包含了 read、write、close 等所有文件操作的接口。不同类型的文件（磁盘文件、键盘、网卡）会实现自己的 read、write 方法，然后通过 file 结构体的 f_op 指针关联起来。
简化后的file_operations定义如下：
struct file_operations {
// 模块所有者（驱动开发相关）
struct module *owner;
// 改变文件读写位置
loff_t (*llseek) (struct file *, loff_t, int);
// 读操作（核心）
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
// 写操作（核心）
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
// 异步读
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
// 异步写
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
// 关闭文件
int (*release) (struct inode *, struct file *);
// 其他操作（如 ioctl、mmap 等）省略...
};
关键逻辑：当我们调用**read(fd, buf, len)**系统调用时，内核会：
通过文件描述符 fd，找到进程 files_struct 中的 file 结构体； 调用 file->f_op->read 方法，执行该文件的具体读操作； 不同类型的文件，read 方法的实现完全不同： 磁盘文件：read 方法会调用磁盘驱动，从磁盘读取数据到内存； 键盘：read 方法会调用键盘驱动，等待用户输入并返回数据； 网卡：read 方法会调用网卡驱动，从网卡缓冲区读取网络数据。
这就是'一切皆文件'的底层实现：统一的接口（read/write）+ 不同的实现（file_operations），屏蔽了硬件差异。
每个进程都有一个task_struct（进程控制块），其中包含一个指向files_struct的指针，files_struct存储了进程打开的所有文件描述符：
// 进程控制块
struct task_struct {
// 指向进程的文件表
struct files_struct *files;
// 其他成员省略...
};
// 进程文件表
struct files_struct {
// 文件描述符数组（fd 是数组下标）
struct file __rcu *fd_array[NR_OPEN_DEFAULT];
// 其他成员省略...
};
结合之前的知识，整个关联链路是：进程（task_struct） → files_struct → fd_array[fd] → file → file_operations → 具体操作（read/write）
我们通过代码验证：无论是磁盘文件、键盘（标准输入）还是显示器（标准输出），都可以用read/write系统调用操作。
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main() {
char buf[1024];
printf("请输入内容（按回车结束）：");
fflush(stdout); // 刷新缓冲区，确保提示语立即显示
// 从键盘（fd=0）读取数据，本质是调用键盘的 read 方法
ssize_t read_len = read(0, buf, sizeof(buf) - 1);
if (read_len < 0) {
perror("read error");
return 1;
}
buf[read_len] = '\0'; // 添加字符串结束符
printf("你输入的内容：%s", buf);
return 0;
}
编译运行：
gcc -o read_keyboard read_keyboard.c
./read_keyboard
运行结果：
请输入内容（按回车结束）：hello 一切皆文件！
你输入的内容：hello 一切皆文件！
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main() {
const char *msg = "向显示器输出：hello write!\n";
// 向显示器（fd=1）写入数据，调用显示器的 write 方法
ssize_t write_len = write(1, msg, strlen(msg));
if (write_len < 0) {
perror("write error");
return 1;
}
printf("实际写入字节数：%zd\n", write_len);
return 0;
}
编译运行：
gcc -o write_display write_display.c
./write_display
运行结果：
向显示器输出：hello write!
实际写入字节数：25
/proc/uptime 是内核生成的虚拟文件，存储系统运行时间，我们可以用 read 读取它：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main() {
// 打开虚拟文件/proc/uptime
int fd = open("/proc/uptime", O_RDONLY);
if (fd < 0) {
perror("open error");
return 1;
}
char buf[128];
ssize_t read_len = read(fd, buf, sizeof(buf) - 1);
if (read_len < 0) {
perror("read error");
close(fd);
return 1;
}
buf[read_len] = '\0';
printf("系统运行时间：%s", buf);
close(fd);
return 0;
}
编译运行：
gcc -o read_proc read_proc.c
./read_proc
运行结果：
系统运行时间：12345.67 87654.32
其中第一个数字是系统总运行时间（秒），第二个是空闲时间。
这三个实战充分说明：无论是硬件设备（键盘、显示器）还是虚拟文件（/proc/uptime），都可以通过统一的 open、read、write 接口操作——这就是'一切皆文件'的实战体现。
上图中的外设，每个设备都可以有自己的 read、write，但一定是对应着不同的操作方法。但通过 struct file 下 file_operation 中的各种函数回调，让我们开发者只用 file 便可调取 Linux 系统中绝大部分的资源。这就是'linux 下⼀切皆文件'这一思想的核心理解。
理解了'一切皆文件'，我们再来看 IO 效率的核心——缓冲区。很多开发者都遇到过这样的问题：用 printf 输出内容，有时候能立即显示，有时候却要等程序结束才显示；用 fwrite 写文件，数据明明调用了函数，却没写入磁盘。这些问题的根源，都是缓冲区在'作祟'。
缓冲区是内存中预留的一块存储空间，用于临时缓存输入/输出数据。它位于 CPU 和外设（磁盘、键盘、显示器）之间，扮演'中间代理'的角色：
输出时：程序先将数据写入缓冲区，缓冲区满了或满足特定条件时，再一次性写入外设；输入时：外设先将数据写入缓冲区，程序再从缓冲区读取数据。
缓冲区本质是一块内存，但它的访问速度比磁盘、键盘等外设快几个数量级（内存访问速度通常是磁盘的 1000 倍以上）。通过缓冲区减少与外设的直接交互次数，就能大幅提升 IO 效率。
引入缓冲区的核心原因有两个：
系统调用（如 read、write）需要切换 CPU 状态（从用户态到内核态），这个切换过程会消耗大量 CPU 时间。如果没有缓冲区，每次读写一个字节都要调用一次系统调用，效率极低。
比如要写入 1000 个字节到文件：
无缓冲区：需要调用 1000 次 write 系统调用，发生 1000 次用户态→内核态切换； 有缓冲区：先将 1000 个字节写入缓冲区，再调用 1 次 write 系统调用写入磁盘，仅发生 1 次状态切换。
CPU 的运算速度是 GHz 级别（每秒数十亿次操作），而磁盘的读写速度是 MB/s 级别（每秒数百万字节），键盘输入速度更是慢到 KB/s 级别。如果没有缓冲区，CPU 会一直等待外设完成操作，造成'CPU 空转'。
比如用打印机打印文档：
无缓冲区：CPU 需要等待打印机打印完每一个字符才能继续工作，效率极低； 有缓冲区：CPU 先将整个文档写入打印机缓冲区，然后可以去处理其他任务，打印机再从缓冲区中逐步打印。
标准 IO 库（C 库）提供了三种缓冲类型，不同类型的缓冲区，刷新时机（将缓冲区数据写入外设）不同：
| 缓冲类型 | 适用场景 | 刷新时机 |
|---|---|---|
| 全缓冲 | 磁盘文件 | 1. 缓冲区满；2. 调用 fflush；3. 进程结束；4. 关闭文件（fclose） |
| 行缓冲 | 终端（键盘、显示器） | 1. 遇到换行符\n；2. 缓冲区满；3. 调用 fflush；4. 进程结束 |
| 无缓冲 | 标准错误流（stderr） | 无缓冲区，数据立即写入外设 |
默认情况下，stdin（标准输入）和 stdout（标准输出）是行缓冲；stderr（标准错误）是无缓冲——确保错误信息能立即显示，不会因为缓冲区未刷新而丢失；当流重定向到磁盘文件时，行缓冲会自动转为全缓冲。
我们通过四个实战案例，彻底搞懂缓冲区的行为。
stdout 默认是行缓冲，遇到**\n**会立即刷新缓冲区：
#include <stdio.h>
#include <unistd.h>
int main() {
printf("hello line buffer 1"); // 无\n，不会立即刷新
sleep(2); // 暂停 2 秒，屏幕无输出
printf(" -> hello line buffer 2\n"); // 有\n，立即刷新
sleep(2); // 暂停 2 秒，屏幕显示完整内容
return 0;
}
编译运行：
gcc -o line_buffer line_buffer.c
./line_buffer
运行现象：
前 2 秒：屏幕无任何输出； 2 秒后：屏幕立即显示hello line buffer 1 -> hello line buffer 2； 再暂停 2 秒，程序结束。
原因：第一句 printf 无\n，数据存入行缓冲区；第二句有\n，触发缓冲区刷新，将两部分数据一起输出。
当 stdout 重定向到文件时，行缓冲转为全缓冲，需缓冲区满或fflush才会刷新：
#include <stdio.h>
#include <unistd.h>
int main() {
// 重定向 stdout 到文件（运行时用 ./full_buffer > log.txt）
printf("hello full buffer 1"); // 存入全缓冲区
printf("hello full buffer 2"); // 存入全缓冲区
sleep(2); // 暂停 2 秒，文件无内容（缓冲区未满）
fflush(stdout); // 强制刷新缓冲区，数据写入文件
sleep(2); // 暂停 2 秒，文件已有内容
return 0;
}
编译运行：
gcc -o full_buffer full_buffer.c
./full_buffer > log.txt
运行现象：
前 2 秒：log.txt 为空（缓冲区未刷新）； 执行 fflush 后：log.txt 出现hello full buffer 1hello full buffer 2； 程序结束后，缓冲区剩余数据会自动刷新（但此案例中已手动刷新）。
stderr 是无缓冲，数据立即写入外设，无需等待：
#include <stdio.h>
#include <unistd.h>
int main() {
fprintf(stderr, "hello stderr 1"); // 无缓冲，立即输出
sleep(2); // 暂停 2 秒，屏幕已显示"hello stderr 1"
fprintf(stderr, " -> hello stderr 2\n"); // 立即输出
sleep(2); // 暂停 2 秒，屏幕显示完整内容
return 0;
}
编译运行：
gcc -o no_buffer no_buffer.c
./no_buffer
运行现象：
程序启动后立即显示hello stderr 1； 2 秒后显示 -> hello stderr 2； 再暂停 2 秒，程序结束。
当进程调用fork创建子进程时，父进程的缓冲区会被复制到子进程（写时拷贝）。如果缓冲区未刷新，父子进程会各自刷新一次，导致数据重复输出。
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main() {
// 库函数 printf（带缓冲区）
printf("hello printf");
// 系统调用 write（无缓冲区）
write(1, "hello write\n", strlen("hello write\n"));
pid_t pid = fork();
if (pid == 0) {
// 子进程
printf(" -> child\n");
} else if (pid > 0) {
// 父进程
waitpid(pid, NULL, 0);
printf(" -> parent\n");
}
return 0;
}
编译运行：
gcc -o fork_buffer fork_buffer.c
./fork_buffer
运行结果：
hello write
hello printf
-> child
hello printf
-> parent
原因：
write是系统调用，无缓冲区，立即输出 hello write； printf无\n，数据存入行缓冲区； fork后，父子进程各有一份缓冲区副本； 父子进程分别执行printf，触发缓冲区刷新，导致 hello printf 输出两次。
./fork_buffer > fork_log.txt
cat fork_log.txt
运行结果：
hello write
hello printf
-> child
hello printf
-> parent
原因：全缓冲未刷新，fork复制缓冲区，父子进程各自刷新，导致重复输出。
修改代码，在fork前添加fflush(stdout)：
printf("hello printf");
fflush(stdout); // 手动刷新缓冲区
write(1, "hello write\n", strlen("hello write\n"));
运行结果：
hello printf
hello write
-> child
-> parent
原因：fork前缓冲区已刷新，父子进程无重复数据，hello printf仅输出一次。
这个案例充分说明：库函数（如 printf、fwrite）带用户级缓冲区，系统调用（如 write、read）无缓冲区。
C 库中的FILE结构体，是缓冲区机制的核心载体。它内部封装了文件描述符（_fileno）和用户级缓冲区的相关信息，让库函数能通过缓冲区减少系统调用。
FILE 结构体定义在/usr/include/libio.h 中，核心成员如下：
struct _IO_FILE {
// 封装的文件描述符（关联内核的 file 结构体）
int _fileno;
// 读缓冲区相关指针
char *_IO_read_base;
char *_IO_read_ptr;
char *_IO_read_end;
// 写缓冲区相关指针
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
// 缓冲区起始地址（统一管理读写缓冲区）
char *_IO_buf_base;
char *_IO_buf_end;
// 其他成员（如刷新标志、锁等）省略...
};
typedef struct _IO_FILE FILE;
当我们调用fwrite写数据时，底层流程是：
fwrite检查FILE结构体的写缓冲区是否有剩余空间； 如果有，将数据拷贝到缓冲区（_IO_write_ptr 指向的位置），并移动_IO_write_ptr； 如果缓冲区满，调用write系统调用（通过_fileno），将缓冲区数据写入内核； 清空缓冲区，_IO_write_ptr重置为_IO_write_base。
这个流程的核心是：数据先入用户级缓冲区，再批量写入内核，减少系统调用次数。
理解了缓冲区和FILE结构体的原理后，我们可以手动封装一个简易的 IO 库（my_stdio），模拟 Glibc 的核心功能——包含mfopen、mfwrite、mfflush、mfclose四个接口，实现行缓冲和全缓冲机制。
定义mFILE结构体，封装文件描述符、缓冲区、刷新模式、缓冲区大小等信息； mfopen：调用 open 系统调用打开文件，初始化 mFILE 结构体（设置缓冲区、刷新模式）； mfwrite：将数据写入缓冲区，根据刷新模式判断是否需要刷新（行缓冲遇到\n，全缓冲满）； mfflush：将缓冲区数据写入内核，清空缓冲区； mfclose：刷新缓冲区，调用 close 系统调用关闭文件，释放资源。
#pragma once
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
// 缓冲区大小（1KB）
#define BUF_SIZE 1024
// 刷新模式
#define FLUSH_NONE 0 // 未设置
#define FLUSH_LINE 1 // 行缓冲（终端）
#define FLUSH_FULL 2 // 全缓冲（文件）
// 自定义 FILE 结构体
typedef struct {
int fileno; // 封装的文件描述符
char buffer[BUF_SIZE]; // 用户级缓冲区
int buf_size; // 缓冲区中已存储的数据大小
int flush_mode; // 刷新模式（行缓冲/全缓冲）
} mFILE;
// 打开文件（模拟 fopen）
mFILE *mfopen(const char *filename, const char *mode);
// 写入数据（模拟 fwrite）
size_t mfwrite(const void *ptr, size_t size, size_t nmemb, mFILE *stream);
// 刷新缓冲区（模拟 fflush）
void mfflush(mFILE *stream);
// 关闭文件（模拟 fclose）
;
#include "my_stdio.h"
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
// 打开文件
mFILE *mfopen(const char *filename, const char *mode) {
int fd = -1;
int flags = 0;
mode_t file_mode = 0666; // 默认文件权限（rw-rw-rw-）
int flush_mode = FLUSH_FULL; // 默认全缓冲
// 解析打开模式
if (strcmp(mode, "r") == 0) {
// 只读模式
flags = O_RDONLY;
} else if (strcmp(mode, "w") == 0) {
// 只写模式，文件不存在则创建，存在则清空
flags = O_WRONLY | O_CREAT | O_TRUNC;
} else if (strcmp(mode, "a") == 0) {
// 追加模式，文件不存在则创建
flags = O_WRONLY | O_CREAT | O_APPEND;
} else if (strcmp(mode, "r+") == 0) {
flags = O_RDWR;
} ((mode, ) == ) {
flags = O_RDWR | O_CREAT | O_TRUNC;
} ((mode, ) == ) {
flags = O_RDWR | O_CREAT | O_APPEND;
} {
(, , mode);
;
}
(flags & (O_CREAT | O_TRUNC | O_APPEND)) {
fd = open(filename, flags, file_mode);
} {
fd = open(filename, flags);
}
(fd < ) {
perror();
;
}
(isatty(fd)) {
flush_mode = FLUSH_LINE;
}
mFILE *mf = (mFILE *)((mFILE));
(mf == ) {
perror();
close(fd);
;
}
mf->fileno = fd;
mf->buf_size = ;
mf->flush_mode = flush_mode;
(mf->buffer, , BUF_SIZE);
mf;
}
{
(ptr == || stream == || size == || nmemb == ) {
;
}
total_bytes = size * nmemb;
remaining_bytes = total_bytes;
*data = ( *)ptr;
(remaining_bytes > ) {
free_space = BUF_SIZE - stream->buf_size;
write_bytes = (remaining_bytes < free_space) ? remaining_bytes : free_space;
(stream->buffer + stream->buf_size, data + (total_bytes - remaining_bytes), write_bytes);
stream->buf_size += write_bytes;
remaining_bytes -= write_bytes;
(stream->flush_mode == FLUSH_LINE) {
((stream->buffer, , stream->buf_size) != ) {
mfflush(stream);
}
} (stream->flush_mode == FLUSH_FULL) {
(stream->buf_size == BUF_SIZE) {
mfflush(stream);
}
}
}
nmemb;
}
{
(stream == || stream->buf_size == ) {
;
}
write_len = write(stream->fileno, stream->buffer, stream->buf_size);
(write_len < ) {
perror();
} (()write_len != stream->buf_size) {
(, , write_len, stream->buf_size);
}
stream->buf_size = ;
(stream->buffer, , BUF_SIZE);
}
{
(stream == ) {
;
}
mfflush(stream);
ret = close(stream->fileno);
(ret < ) {
perror();
}
(stream);
stream = ;
ret;
}
#include "my_stdio.h"
#include <stdio.h>
#include <unistd.h>
int main() {
// 测试 1：写入终端（行缓冲）
printf("=== 测试行缓冲（终端输出） ===\n");
mFILE *mf_terminal = mfopen("/dev/stdout", "w"); // /dev/stdout 是终端
if (mf_terminal == NULL) {
return 1;
}
mfwrite("测试行缓冲 1：无换行符", 1, strlen("测试行缓冲 1：无换行符"), mf_terminal);
sleep(2); // 暂停 2 秒，无输出（缓冲区未刷新）
mfwrite(" -> 测试行缓冲 2：有换行符\n", 1, strlen(" -> 测试行缓冲 2：有换行符\n"), mf_terminal);
sleep(2); // 暂停 2 秒，已输出（遇到\n 刷新）
mfclose(mf_terminal);
// 测试 2：写入文件（全缓冲）
printf("\n=== 测试全缓冲（文件输出） ===\n");
mFILE *mf_file = mfopen("test_my_stdio.txt", "w");
if (mf_file == NULL) {
return 1;
}
// 写入小于缓冲区大小的数据（1KB）
const char *msg = "测试全缓冲：写入文件的数据";
mfwrite(msg, 1, strlen(msg), mf_file);
printf("写入数据后，文件暂时无内容（缓冲区未满）\n");
sleep();
mfflush(mf_file);
();
sleep();
mfclose(mf_file);
();
mFILE *mf_big = mfopen(, );
(mf_big == ) {
;
}
big_msg[BUF_SIZE + ];
(big_msg, , (big_msg));
big_msg[(big_msg) - ] = ;
mfwrite(big_msg, , (big_msg), mf_big);
();
mfclose(mf_big);
;
}
gcc -o test_my_stdio main.c my_stdio.c
./test_my_stdio
全缓冲满刷新：
写入 1124 字节（1KB+100 字节），缓冲区满，自动刷新； test_big.txt 中出现大量 a 字符（缓冲区数据已写入文件）。
全缓冲测试：
写入数据后，test_my_stdio.txt 为空（缓冲区未满）； 调用 mfflush 后，test_my_stdio.txt 出现写入的数据（手动刷新）。
行缓冲测试：
前 2 秒：终端无输出（数据存入行缓冲区，无\n）； 2 秒后：终端输出
测试行缓冲 1：无换行符 -> 测试行缓冲 2：有换行符（遇到\n 刷新）。
这个手动封装的 IO 库，成功模拟了 Glibc 的核心缓冲机制，让我们更深刻地理解了缓冲区的工作原理。
掌握了本文涉及的这些知识点后，你不仅能熟练使用文件 IO 接口，还能解决实际开发中遇到的缓冲区、重定向等疑难问题。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online