Linux | 缓冲区理解 | 模拟实现C语言文件操作函数

何为缓冲区？

缓冲区的本质就是一段内存，数据进行传输时，不是直接向目的地传输，而是先传输到缓冲区中，当缓冲区满足一定条件时（刷新策略不同导致条件不同），才会将数据向目的地传输。

为什么要有缓冲区？

1.缓冲区可以解放进程传输数据时间，进程需要传输数据时，只要将数据交给缓冲区，剩下的事全都由缓冲区负责，进程可以去完成其他的工作
2.缓冲区可以减少IO次数，相比于操作系统，外设的速度是很慢的，每一次IO操作都会消耗大量时间，缓冲区将数据集中传输，极大的提高了整体的效率

缓冲区在哪？

操作系统中存在缓冲区，语言中也存在缓冲区，这篇博客讲解的是语言的缓冲区。下面写代码验证缓冲区的存在

// buffer.c 文件
#include 
#include 
#include 

int main()
{
	const char* str1 = "hello printf\n";
	const char* str2 = "hello fprintf\n";
	const char* str3 = "hello fputs\n";
	const char* str4 = "hello write\n";
	// stdio
	printf(str1);
	fprintf(stdout, str2);
	fputs(str3, stdout);
	
	// system
	write(1, str4,strlen(str4));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（分别用C语言的文件接口和操作系统的文件接口输出数据，当数据以’\n’结尾时，所有的数据都能正常输出）

// buffer.c 文件
#include 
#include 
#include 

int main()
{
	const char* str1 = "hello printf ";
	const char* str2 = "hello fprintf ";
	const char* str3 = "hello fputs ";
	const char* str4 = "hello write ";
	// stdio
	printf(str1);
	fprintf(stdout, str2);
	fputs(str3, stdout);
	
	// system
	write(1, str4,strlen(str4));
	sleep(3);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

（将数据的’\n’替换成空格，并在最后使程序休眠3秒，通过打印结果发现，一开始只有write函数打印了数据，其他函数在3秒之后才打印出数据）


巧的是，write是系统接口，而其他函数都是C语言的文件接口，为什么C语言的文件接口没有直接打印出数据呢？

我们经常听到一句话，getchar函数会从缓冲区中读取一个字符，也就是说，输入数据时，数据存储在了缓冲区中等待被读取，输入数据如此，输出数据也是如此。很显然C语言在输出数据时，没有直接调用write函数，而是将这些数据放到了缓冲区中，直到缓冲区刷新时，才会调用write输出数据。可以从上面的代码看出，三个输出函数输出的数据未能使缓冲区达到刷新条件，所以数据先被暂存到了缓冲区中，最后由于进程退出，缓冲区的数据被强制输出到显示器上。

因为write函数直接输出数据，没有经过缓冲区，所以这里讨论的缓冲区不是属于系统的，而是属于语言的，因为C语言的函数接口没有直接输出数据，先将数据放到了缓冲区中，这个缓冲区必然是由C语言管理的。

所以说C语言将文件封装为FILE，除了对fd和读写方法的封装，FILE肯定还封装了一个缓冲区，这个缓冲区由语言维护，由语言负责创建和释放。

在缓冲区刷新之前关闭系统文件

// buffer.c 文件
#include 
#include 
#include 

int main()
{
	const char* str1 = "hello printf ";
	const char* str2 = "hello fprintf ";
	const char* str3 = "hello fputs ";
	const char* str4 = "hello write ";
	// stdio
	printf(str1);
	fprintf(stdout, str2);
	fputs(str3, stdout);
	
	// system
	write(1, str4,strlen(str4));
	sleep(3);
	close(1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

修改之前的代码，在进程休眠3秒后关闭fd为1的文件。通过结果我们发现只有write函数输出了数据，其他函数没有输出数据，为何？因为C语言的文件操作函数将输出的数据先存储在缓冲区中，直到缓冲区刷新时，进程才会调用系统的write函数向显示器打印信息，很显然直到进程退出，缓冲区的数据都没有刷新。

C语言的文件操作函数调用write函数时，write的参数是什么？因为是向显示器输出信息，所以write的第一个参数fd为1，第二个参数buf肯定是FILE内部的缓冲区，最后一个参数count，进程也会自己算出。但是在缓冲区刷新前（进程退出会强制刷新缓冲区），将fd为1的文件关闭，那么调用write函数时，fd为1的文件是一个不存在的文件，向一个不存在的文件输出信息，write函数肯定调用失败，所以缓冲区的数据没地方输出，此时进程不会打印任何信息，所以以上代码只输出了hello write

想要输出剩下的信息，就需要在关闭系统文件前手动调用fflush函数刷新缓冲区。这段代码也证明了缓冲区是存在于C语言FILE中的结构

缓冲区的刷新策略

刷新策略分为两种，一是常规刷新，一是特殊刷新。

常规刷新：
1.无缓冲（立即刷新）
2.行缓冲（将一行的数据刷新，也就是换行符之前的数据），显示器的刷新策略就是行缓冲
3.全缓冲（缓冲区满了才刷新），块设备采用这种刷新策略，也就是磁盘中的文件
特殊刷新：
1.用户强制刷新，fflush
2.进程退出，释放缓冲区资源之前将缓冲区清空，并且将数据输出到文件中

正是利用了stdout的刷新策略属于行缓冲，以上代码才能引出缓冲区的问题。

代码解读

int main()
{
	const char* str1 = "hello printf\n";
	const char* str2 = "hello fprintf\n";
	const char* str3 = "hello fputs\n";
	const char* str3 = "hello write\n";
	
	// stdio
	printf(str1);
	fprintf(stdout, str2);
	fputs(str3, stdout);
	
	// system
	write(1, str4,strlen(str4));
	fork();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

以上代码在最后调用fork，创建子进程执行于父进程系统的代码。并且将还进程输出重定向到一个磁盘文件中，为什么该程序会输出7条语句，hello write只输出一次，其他语句输出两次？

将程序的输出由标准输出重定向到一个磁盘文件中，由于磁盘文件的缓冲区采用全刷新策略，C语言的文件接口将三条语句输出到该文件的缓冲区中，但缓冲区还没有满，所以没有将数据刷新到文件中。只有write函数先将数据输出到文件中。程序最后调用fork创建子进程，由于父子进程代码共享，数据通过写时拷贝的方式共享，父进程的标准输出流文件FILE也作为数据被共享给了子进程，其中包括了FILE的缓冲区，当父子进程其中的一个进程退出时需要清空缓冲区，缓冲区的三条语句会被输出到文件中，但因为进程清空了缓冲区，触发了写时拷贝，另一个进程将拷贝清空之前的缓冲区，保证两进程的数据不会互相影响。所以，最后退出的一个进程，清空文件的缓冲区，即又将三条语句输出到文件中。所以C语言函数将三条语句输出了两次，系统函数输出的语句只输出了一次。

C语言文件操作函数模拟实现

#include 
#include 
#include 
#include 
#include 
#include 
#include 

// 缓冲区的长度
#define NUM 256

// 刷新策略的宏定义
#define NONE_FLUSH 0x0
#define ALL_FLUSH 0x1
#define LINE_FLUSH 0x2

// 根据之前的理解，文件结构体中不仅要封装文件描述符，还要封装一个缓冲区，
// 此外_end表示缓冲区的长度，_flags表示该文件的刷新策略
typedef struct my_file
{
	int _fileno;         // 文件描述符
	char _buffer[NUM];   // 缓冲区
	int _flags;          // 文件的刷新策略
	int _end;            // 缓冲区的长度  
}my_file;

my_file* my_fopen(const char* filename, const char* mode)
{
	int method = O_RDONLY;
	// 根据mode判断文件的打开方式，这里只实现两个打开方式
	if (strcmp(mode, "w") == 0) 
	{
		method = O_CREAT | O_WRONLY | O_TRUNC; 
	}
	else if (strcmp(mode, "w+") == 0) {}
	else if (strcmp(mode, "r") == 0) {}
	else if (strcmp(mode, "r+") == 0) {}
	else if (strcmp(mode, "a") == 0) 
	{
		method = O_CREAT | O_APPEND | O_WRONLY;
	}
	else if (strcmp(mode, "a+") == 0) {}
	else
	{
		printf("打开方式错误\n");
	}
	// 为文件结构体分配空间
	my_file* file = (my_file*)malloc(sizeof(my_file));
	// 调用系统接口打开文件，并保存文件描述符到_fileno中
	file->_fileno = open(filename, method, 0666);
	if (file->_fileno < 0)
		return NULL; // 文件打开失败返回空
	// 初始化_end
	file->_end = 0;
	// 创建的文件默认采用行刷新，其他刷新方式暂不实现
	file->_flags |= LINE_FLUSH; 
	return file;
}

void my_fwrite(my_file* file, const char* buffer, size_t count)
{
	// 行缓冲
	// 从原有数据之后开始写数据，并改变_end
	strcpy(file->_buffer + file->_end, buffer);
	file->_end += count;
	// 如果文件的刷新方式是行刷新
	if (file->_flags & LINE_FLUSH)
	{
		// 当最后一个字符为换行符时，需要刷新
		if (_end > 0 && file->_buffer[strlen(file->_buffer) - 1] == '\n')
		{
			// 刷新就是将调用write将数据写到文件中，别忘了重置缓冲区
			write(file->_fileno, file->_buffer, file->_end);
			memset(file->_buffer, 0, sizeof(file->_buffer));
			file->_end = 0;
		}
	}
	else if (file->_flags & ALL_FLUSH) {}
	else if (file->_flags & NONE_FLUSH) {}
	else 
	{
		printf("文件刷新策略错误\n");
	}
}

// 缓冲区的刷新
void my_fflush(my_file* file)
{
	if (file->_end > 0) // 缓冲区中有数据
	{
		write(file->_fileno, file->_buffer, file->_end);
		memset(file->_buffer, 0, file->_end);
		file->_end = 0;
	}
}

void my_fclose(my_file* file)
{
	my_fflush(file);  // 关闭前刷新文件缓冲区
	close(file->_fileno);
	free(file);
}

int main()
{
	my_file* file = my_fopen("log.txt", "w");
	char s1[] = { "hello myfile\n" };
	my_fwrite(file, s1, strlen(s1));
	printf("写入满足条件的字符串\n");
	sleep(2);
	
	char s2[] = { "can't see me" };
	my_fwrite(file, s2, strlen(s2));
	printf("写入不满足条件的字符串\n");
	sleep(2);
	
	char s3[] = { "can see me\n" };
	my_fwrite(file, s3, strlen(s3));
	printf("写入满足条件的字符串\n");
	sleep(2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

最后测试程序：总共写入三次数据，第一次数据满足刷新条件，文件中立即出现数据，第二次不满足刷新条件，数据存储在缓冲区中，第三次满足刷新条件，第三次输出的数据连同第二次输出的数据一起刷新到文件中。

复制会话，写一个脚本不断输出文件内容，观察数据的写入是否于预测相符

第一条数据写入文件成功

第二条数据不满足，无法写入

最后一条数据满足刷新条件，缓冲区的所有数据会被刷新到文件中

int main()
{
	my_file* file = my_fopen("log.txt", "w");
	char s1[] = { "hello myfile\n" };
	my_fwrite(file, s1, strlen(s1));
	printf("写入满足条件的字符串\n");
	sleep(2);
	
	char s2[] = { "can't see me" };
	my_fwrite(file, s2, strlen(s2));
	printf("写入不满足条件的字符串\n");
	sleep(2);
	
	fork();
	my_fclose(file);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

修改代码，写入满足刷新条件的数据后，写入一段不满足刷新条件的数据，然后调用fork，最后调用my_close模拟进程退出，刷新缓冲区，结果是文件中有两段不满足条件的数据