Linux 基础 IO 总结

Linux 基础 IO：从文件描述符到重定向、缓冲区和文件系统

在 Linux 学习中，IO 是非常核心的一部分。很多同学刚开始接触文件操作时，只知道 fopen、fread、fwrite、open、read、write 这些接口，但如果只停留在“会用接口”的层面，就很难真正理解 Linux 下文件、进程、重定向、缓冲区以及文件系统之间的关系。

这篇文章围绕 Linux 基础 IO 展开，重点总结以下几个问题：

1. 文件操作的本质是什么？

2. C 文件接口和系统调用接口有什么关系？

3. 文件描述符 fd 到底是什么？

4. 重定向的本质是什么？

5. C 缓冲区和系统调用有什么区别？

6. Linux 文件系统如何管理磁盘文件？

7. 软链接、硬链接和动静态库如何理解？

本文内容整理自 BIT.5_基础IO.pdf 的学习笔记。

一、重新理解文件：文件操作的本质是什么？

很多人一开始会认为：

文件就是磁盘上的一段数据。

这个理解不算错，但不够完整。

在 Linux 中，一个文件可以理解为：

文件 = 内容 + 属性

文件内容就是我们写入的数据，比如文本、图片、二进制内容等。

文件属性包括文件大小、权限、所属用户、所属组、创建时间、修改时间、inode 编号等。

所以，文件操作也可以理解为：

文件操作 = 内容操作 + 属性操作

例如：

• read/write 主要操作文件内容；

• chmod/chown/stat 主要操作或查看文件属性；

• open/close 建立或解除进程与文件之间的关系。

更重要的是，文件操作并不是代码写完就发生了。比如我们写了：

fopen("log.txt", "w");
fprintf(fp, "hello linux\n");
fclose(fp);

这段代码只有在程序运行时才会真正执行文件操作。

所以文件操作的本质是：

进程对被打开文件的操作

一个文件如果没有被某个进程打开，那么这个进程就无法直接访问它。用户进程不能绕过操作系统直接访问磁盘，必须通过 OS 提供的接口完成文件访问。

二、C 文件接口和系统调用接口的关系

我们平时在 C 语言中经常使用：

fopen
fclose
fread
fwrite
fprintf
fgets

这些接口属于 C 标准库接口。

而 Linux 系统调用接口常见的是：

open
close
read
write
lseek

它们之间的关系可以理解为：

C库函数是上层封装
系统调用是底层接口

不同语言的文件操作接口可能不同：

• C 有 fopen/fwrite

• C++ 有 fstream

• Python 有 open/read/write

• Java 有各种 IO 类

• Go 也有自己的文件接口

但是它们最终都绕不开操作系统。

因为磁盘是硬件资源，所有用户程序都不能直接访问硬件，必须通过操作系统。

所以学习 Linux IO 时，真正“不变”的部分是：

操作系统提供的系统调用接口

这也是为什么学习 open/read/write/close 很重要。

三、C 文件打开模式总结

C 语言中 fopen 常见模式如下：

其中最容易混淆的是：

w：会清空原文件内容
a：不会清空，而是追加到文件末尾
r：文件不存在会失败

例如：

FILE* fp = fopen("log.txt", "w");

如果 log.txt 已经存在，那么原来的内容会被清空。

而：

FILE* fp = fopen("log.txt", "a");

则是在文件末尾继续追加内容。

四、open 系统调用：理解标志位

Linux 中使用 open 打开文件：

int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

这里的 O_WRONLY | O_CREAT | O_TRUNC 就是通过位图的方式传递多个选项。

常见标志位如下：

几个典型场景：

// 清空后写入
open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

// 追加写日志
open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);

// 只读打开
open("log.txt", O_RDONLY);

// 防止重复启动的锁文件
open("lock.pid", O_WRONLY | O_CREAT | O_EXCL, 0666);

这里要注意：

0666

只是文件创建时给出的默认权限，最终权限还会受到 umask 影响。

例如：

umask(0);

可以临时把权限掩码清空，使创建权限更接近传入的 0666。

五、文件描述符 fd 是什么？

使用 open 成功后，会返回一个整数：

int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

这个整数就是文件描述符。

很多人刚学的时候会误以为 fd 就是文件本身，其实不是。

fd 是进程用来访问打开文件的下标。

在 Linux 中，每个进程都有一张文件描述符表，可以简单理解为：

进程 PCB
  └── files_struct*
        └── fd_array[]
              ├── 0 -> stdin
              ├── 1 -> stdout
              ├── 2 -> stderr
              ├── 3 -> 某个打开的文件
              ├── 4 -> 某个打开的文件

默认情况下：

所以我们自己打开的普通文件，通常从 fd = 3 开始。

fd 的分配规则是：

从小到大，找到当前没有被使用的最小 fd

例如，如果关闭标准输出：

close(1);

然后再打开一个文件：

int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

那么这个新文件很可能拿到 fd = 1。

这就是理解重定向的关键。

六、重定向的本质

我们平时在 shell 中经常使用：

./a.out > log.txt

它的含义是：原本应该输出到显示器的数据，现在输出到 log.txt 文件。

那么重定向的本质是什么？

答案是：

改变文件描述符表中 fd 对应的 struct file* 指向

也就是说，上层程序仍然往 fd = 1 写数据，但是 fd = 1 不再指向显示器，而是指向某个普通文件。

Linux 提供了 dup2 来完成这个操作：

int dup2(int oldfd, int newfd);

例如输出重定向：

int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
dup2(fd, 1);

执行后：

fd = 1 不再指向显示器
fd = 1 指向 log.txt

所以：

printf("hello linux\n");
write(1, "hello\n", 6);

都会写入 log.txt。

输出重定向

int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
dup2(fd, STDOUT_FILENO);

对应 shell：

cmd > log.txt

追加重定向

int fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);
dup2(fd, STDOUT_FILENO);

对应 shell：

cmd >> log.txt

输入重定向

int fd = open("input.txt", O_RDONLY);
dup2(fd, STDIN_FILENO);

对应 shell：

cmd < input.txt

七、shell 是如何实现重定向的？

shell 执行普通命令时，通常流程是：

shell 读取命令
解析命令和重定向符号
fork 创建子进程
子进程处理重定向
子进程 exec 程序替换
父进程 wait 等待

为什么重定向一般由子进程完成？

因为如果父进程，也就是 shell 自己修改了 fd，那么 shell 自己的输入输出也会被影响。

所以 shell 的正确做法是：

父进程解析命令
子进程完成 dup2
子进程 exec 执行目标程序

而 exec 程序替换不会改变进程已经打开的文件描述符表。

也就是说，子进程先完成重定向，再执行程序替换，替换后的程序依然继承之前的重定向关系。

这就是 shell 重定向能够生效的根本原因。

八、C 缓冲区和 write 的区别

一个经典问题：

printf("hello printf\n");
fprintf(stdout, "hello fprintf\n");
fputs("hello fputs\n", stdout);

write(1, "hello write\n", 12);

fork();

如果直接输出到显示器，结果可能正常。

但如果执行：

./a.out > log.txt

可能会发现 printf/fprintf/fputs 的内容出现两份，而 write 的内容只出现一份。

为什么？

关键在于：

printf/fprintf/fputs 使用 C 库缓冲区
write 直接使用系统调用

C 标准库的 FILE* 内部维护了一块用户级缓冲区。

例如：

stdout -> FILE结构体 -> fd + 用户缓冲区

当输出目标是显示器时，stdout 通常是行缓冲，遇到 \n 就刷新。

当输出目标变成普通文件时，stdout 通常变成全缓冲。此时即使有 \n，也不一定马上刷新。

如果在缓冲区还没有刷新时调用 fork()，子进程会复制父进程的用户空间数据。

于是父子进程各自都有一份尚未刷新的 C 缓冲区。

进程退出时，父子进程都会刷新自己的缓冲区，于是 C 库输出可能写入两次。

但是 write 不一样。

write 调用时，数据已经交给内核，不存在 C 库中的待刷新缓冲区，所以不会因为 fork 复制用户态缓冲区而重复输出。

避免方式：

fflush(stdout);
fork();

或者尽量不要在 fork 前留下未刷新的 C 缓冲区。

九、缓冲区的刷新策略

缓冲区的本质是一段内存。

它的作用是：

减少频繁 IO，提高效率

如果每写一个字符就访问一次外设，效率非常低。

所以 C 库会先把数据放进缓冲区，满足条件后再统一刷新。

常见刷新策略：

除此之外，还有一些特殊刷新时机：

1. 用户主动调用 fflush
2. fclose 关闭文件
3. 进程正常退出

需要注意的是：

C库缓冲区在用户空间
内核也有自己的缓冲区
磁盘是最终落盘位置

也就是说：

用户数据
  -> C库缓冲区
  -> write系统调用
  -> 内核缓冲区
  -> 磁盘

fflush 主要刷新 C 库缓冲区到内核。

如果希望进一步要求内核尽快刷到磁盘，可以使用：

fsync(fd);

十、Linux 一切皆文件

Linux 中有一句经典的话：

一切皆文件

它并不是说所有东西都是普通磁盘文件，而是说很多资源都可以用类似文件的方式管理和访问。

例如：

• 普通文件

• 目录

• 管道

• 设备

• socket

• 标准输入输出

它们都可以通过统一的接口进行操作：

open
read
write
close

这背后的思想有点像 C++ 的多态。

不同类型的文件对象，底层有不同的操作方法，但上层可以使用统一接口访问。

Linux 内核中会用类似函数指针的方式，让不同文件类型实现自己的读写逻辑。

十一、磁盘和文件系统

文件没有被打开时，是“静静躺在磁盘上”的。

那么磁盘上的文件是如何被管理的？

首先要理解磁盘的基本结构。

传统机械硬盘中有：

盘面
磁道
扇区
柱面
磁头

磁盘访问的基本单位通常是扇区，一个扇区常见大小是 512 字节。

但是操作系统通常不会只按 512 字节管理文件，因为太小了，效率低。

所以文件系统往往以更大的块为单位管理磁盘，比如：

1KB
2KB
4KB

常见情况下，一个 block 是 4KB。

为什么是 4KB？

因为局部性原理。

当我们访问某个位置的数据时，很可能接下来还会访问它附近的数据。一次加载更多相邻数据，可以减少磁盘 IO 次数。

十二、inode：文件属性和文件内容分离

Linux 文件系统中，一个重要概念是 inode。

一个文件可以理解为：

文件 = inode + data block

其中：

inode 保存文件属性
data block 保存文件内容

inode 中通常保存：

• 文件权限

• 文件大小

• 所属用户

• 所属组

• 时间信息

• 数据块位置

• 硬链接计数

但注意：

文件名不在 inode 中

文件名存在哪里？

答案是目录的数据块中。

目录也是文件。

目录的内容保存的是：

文件名 -> inode编号

所以查找一个文件的过程大致是：

根据路径进入目录
在目录内容中找到文件名和 inode 的映射
根据 inode 找到文件属性
根据 inode 中的数据块指针找到文件内容

这也是为什么 Linux 中删除文件时，并不一定马上清空磁盘数据。

删除本质上通常是解除：

文件名 -> inode

的映射关系，并更新 inode 引用计数、bitmap 等信息。

十三、文件系统的基本结构

一个文件系统通常会被分成多个块组，每个块组中包含若干管理结构。

常见结构如下：

可以简单理解为：

Super Block：整个文件系统的说明书
GDT：每个块组的管理信息
Block Bitmap：哪些数据块空闲
Inode Bitmap：哪些 inode 空闲
Inode Table：文件属性仓库
Data Blocks：真正存文件内容的地方

十四、软链接和硬链接

Linux 中有两种链接：

ln -s oldfile softlink
ln oldfile hardlink

软链接

软链接类似 Windows 下的快捷方式。

特点：

软链接有自己独立的 inode
软链接文件内容保存的是目标文件路径
目标文件删除后，软链接可能失效

例如：

ln -s test.txt test_soft

test_soft 是一个独立文件，它的内容指向 test.txt 的路径。

硬链接

硬链接的本质是：

新增一个文件名和 inode 编号的映射关系

也就是说，硬链接不会创建新的 inode。

多个文件名可以指向同一个 inode。

例如：

ln test.txt test_hard

此时：

test.txt 和 test_hard 指向同一个 inode

inode 中有一个硬链接计数。

只有当硬链接计数变成 0 时，这个文件才真正可以被删除。

所以硬链接可以理解为：

多个文件名共享同一份文件属性和文件内容

十五、动静态库的本质

Linux 下常见库文件：

静态库：.a
动态库：.so

库文件的本质是：

多个 .o 文件的集合

.o 文件是编译后的可重定位目标文件。

如果我们不想把源码交给别人，可以提供：

头文件 .h：告诉别人有哪些函数
库文件 .a/.so：提供函数实现

静态库

创建静态库：

gcc -c add.c
gcc -c sub.c
ar -rc libmymath.a add.o sub.o

使用静态库：

gcc main.c -I ./include -L ./lib -l mymath

其中：

-I 指定头文件路径
-L 指定库文件路径
-l 指定库名

注意：

-l mymath

对应的实际库文件名是：

libmymath.a

也就是去掉前缀 lib 和后缀 .a。

动态库

生成动态库：

gcc -fPIC -c add.c
gcc -fPIC -c sub.c
gcc -shared -o libmymath.so add.o sub.o

使用动态库编译：

gcc main.c -I ./include -L ./lib -l mymath

但是动态库有一个问题：

编译时能找到，不代表运行时能找到

运行时需要操作系统找到 .so 文件。

常见解决方法：

1. 设置环境变量：

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/your/lib/path

1. 配置 /etc/ld.so.conf.d/，然后执行：

ldconfig

1. 将动态库放到系统默认搜索路径中。

十六、静态库和动态库的区别

静态库和动态库最大的区别在于：

静态库在链接时被拷贝进可执行程序
动态库在运行时被加载和映射

静态库

优点：

运行时不依赖外部库
部署简单

缺点：

可执行程序体积较大
多个程序使用同一份库代码时，会产生重复拷贝
库更新后需要重新链接程序

动态库

优点：

多个进程可以共享同一份库代码
程序体积更小
库升级更灵活

缺点：

运行时必须能找到对应 .so 文件
环境配置更复杂

十七、总结

Linux 基础 IO 不是简单背几个接口，而是要建立一条完整的理解链：

文件 = 内容 + 属性
文件操作 = 进程对被打开文件的操作
C库接口 = 对系统调用的封装
fd = 进程文件描述符表的下标
重定向 = 修改 fd 对应的文件指向
缓冲区 = 用户级 FILE 结构体中的一段内存
write = 直接进入系统调用层
文件系统 = inode + data block + bitmap + super block
目录 = 文件名和 inode 的映射关系
硬链接 = 新增文件名和 inode 的映射
软链接 = 保存目标路径的独立文件
库文件 = 多个 .o 文件的集合

如果把 Linux IO 学透，后面理解这些内容都会更轻松：

• shell 重定向

• 管道

• 进程间通信

• socket 编程

• select/poll/epoll

• Reactor 模型

• Web 服务器

• 日志系统

• 文件系统原理

• 动静态链接

• 进程地址空间

一句话总结：

Linux IO 的核心，不只是“读写文件”，而是理解进程、文件描述符、内核对象、缓冲区和文件系统之间的关系。