Linux 缓冲区

概念

• 用于临时存储数据的内存区域，目的是优化设备 I/O 操作，以提高传输效率
  

刷新方式

• 无缓冲(立刻刷新)：write
  
• 行缓冲(行刷新)：显示器文件
  
• 全缓冲(缓冲区满刷新)：磁盘文件
  

刷新策略

• 强制刷新(fflush)
  
• 历程退出的时候，刷新缓冲区
  

样例实行

1.   1 #include <stdio.h>
2.   2 #include <unistd.h>
3.   3 #include <string.h>
4.   4
5.   5 const char* str1 = "C library: fputs\n";
6.   6 const char* str2 = "system call: write\n";
7.   7 int main()
8.   8 {
9.   9     printf("C library: printf\n");
10. 10     fprintf(stdout, "C library: fprintf\n");
11. 11     fputs(str1, stdout);
12. 12     write(1, str2, strlen(str2));
13. 13     //fork();                                                                                                                                 
14. 14     return 0;            
15. 15 }

复制代码

无fork

向显示器文件打印

• 缓冲区的刷新方式是：行刷新
  
• 前三个C库函数，不停留在C语言的缓冲区，直接出来
  
• 以是体系调用接口着实最后呈现
  

向磁盘文件打印

• 缓冲区的刷新方式是：全刷新
  
• 前三个C库函数所打印的内容没有填满C语言缓冲区，以是着实步伐结束的时候才刷新缓冲区
  
• 体系调用接口不经过C语言缓冲区，导致他先打印在前面
  

有fork

为什么重定向到磁盘文件的时候会多打印？
磁盘文件里的体系调用那句没有多打印？
是因为fork起作用了？那为什么显示器文件就没有呢？
办理这些问题的关键是打印二字

• 打印可以理解成一种刷新的方式
  
• 打印过程并不是直接步伐到文件
  

• self buffer：被写入的数据
  
• 刷新：C buffer拷贝到文件缓冲区的过程，即：用户到操作体系
  
• 调用C库函数的时候，先是拷贝到C buffer里；对应体系调用接口是不经过C buffer，直接拷贝到文件缓冲区里
  

原理

• 最根本的还是对fork创建子历程的补充和理解
  
• 大概对C buffer不是特殊了解；这就是一个内存区域，这个区域的地址通过页表，与虚拟地址空间映射
  
• 着实就是子历程也有，于内存上是同一份；但是注意：每个历程都有本身独立的虚拟地址空间和页表，这里他们的内容一样，以是指向同一个缓冲区
  
• 那么问题就办理了，子历程结束的时候会刷新缓冲区，以是会有两份；体系调用打印的内容不在C语言缓冲区里，以是子历程没有
  

问题与补充

1.对printf的理解

• 边拷贝，边做字符串分析
  
• printf封装了write
  
• 刷新本质都是通过write实现的
  
• printf每次都会往C buffer里写，但并不是每次都刷新，是按照刷新方式来决定是这次printf否调用write
  

2.对write的理解

• 不是说write不会将数据放入C语言缓冲区吗？是的，不抵牾
  
• C buffer 和self buffer一样都只是一个用于存放数据的内存区域，只不外C buffer 大点，就是为了一次性刷新多点数据，来提高步伐的效率
  
• 以是说write的本质就是将C buffer 大概 self buffer里的数据直接(不停留的)刷新到文件缓冲区
  
• 换句话说write不依赖C buffer，但是write可以刷新C buffer
  

3.对 “清空” 的理解

• 缓冲区刷新之后会被清空，清空并不是对物理内存数据的清空
  
• 用字段就可以表示当前缓冲区的有效数据长度或当前位置
  
• 以是上面的代码，在子历程刷新的时候是发生了写实拷贝的
  

4.对 “文件缓冲区” 的理解

• 属于操作体系，不属于历程
  

5.步伐并不知道是否重定向，那么是怎么决定缓冲区的刷新方式的？

• 当 stdout 被重定向到文件时，C 标准库会自动检测到输出流的目标发生了变化，并根据不同的流类型调解缓冲区的刷新策略
  
• 终端检测：标准库通过 isatty() 体系调用来判定标准输出是否连接到终端；假如标准输出是终端设备，则使用行缓冲；假如标准输出被重定向到文件或其他非终端设备，则使用全缓冲
  
• 总结：C 标准库在第一次打开或使用流时，通过检测文件描述符 1（即 stdout）对应的文件属性来决定缓冲方式
  

FILE

 

• 可以通过FILE对象来找到缓冲区
  
• C 语言提供的缓冲区（C buffer）和 FILE 布局体中的缓冲区是一样的，它们指的是同一个概念
  

用体系调用封装C库函数

main.c

1. #include "mystdio.h"
2. #include <stdio.h>
3. int main()
4. {
5.     myFILE* fp = my_fopen("./log.txt", "w");
6.     if(fp == NULL)
7.     {
8.         perror("my_fopen");
9.         return -1;
10.     }
12.     int cnt = 5;
13.     const char* msg = "abcde\n12345";
14.     while(cnt--)
15.     {
16.         my_fwrite(msg, strlen(msg), fp);
17.         //my_fwrite(msg, sizeof(msg), fp);
18.         sleep(1);
19.     }
20.     my_fclose(fp);
21.     return 0;
22. }

复制代码

mystdio.h

1. #pragma once
2. #include <string.h>
3. #include <sys/types.h>
4. #include <sys/stat.h>
5. #include <fcntl.h>
6. #include <errno.h>
7. #include <stdlib.h>
8. #include <unistd.h>
9. #include <stdio.h>
11. #define DFL_MODE 0666
12. #define FFLUSH_LINE 1
13. #define SIZE_BUFFER 1024
15. typedef struct _myFILE
16. {
17.     int fileno;
18.     int flag;
19.     char buffer[SIZE_BUFFER];
20.     int end;
21. }myFILE;
23. myFILE* my_fopen(const char* path, const char* mode);
24. int my_fwrite(const char* str, int num, myFILE* stream);
25. int my_fflush(myFILE* stream);
26. int my_fclose(myFILE* stream);

复制代码

mystdio.c

1. #include "mystdio.h"
3. myFILE* my_fopen(const char* path, const char* mode)
4. {
5.     int fd = 0;
6.     int flags = 0;
7.     if(strcmp(mode, "r") == 0)
8.         flags |= O_RDONLY;
9.     else if(strcmp(mode, "w") == 0)
10.         flags |= (O_WRONLY | O_TRUNC | O_CREAT);
11.     else if(strcmp(mode, "a") == 0)
12.         flags |= (O_APPEND | O_WRONLY | O_CREAT);
13.    
14.     if(flags | O_TRUNC)
15.         fd = open(path, flags, DFL_MODE);
16.     else fd = open(path, flags);
17.    
18.     if(fd < 0)
19.     {
20.         errno = 2;
21.         return NULL;
22.     }
24.     myFILE* fp = (myFILE*)malloc(sizeof(myFILE));//自定义类型要加()
25.     if(fp == NULL)
26.     {
27.         errno = 3;
28.         return NULL;
29.     }
31.     fp->fileno = fd;
32.     fp->flag = FFLUSH_LINE;
33.     fp->end = 0;
34.     return fp;
35. }
37. int my_fwrite(const char* str, int num, myFILE* stream)
38. {
39.     memcpy(stream->buffer + stream->end, str, num);
40.     //stream->end += num;
42.     // 判断是否需要刷新, "abcd\nefgh"
43.     //if((stream->flag & FFLUSH_LINE) && stream->end > 0 && stream->buffer[stream->end-1] == '\n')
44.     //{
45.     //    my_fflush(stream);
46.     //}
47.     int last_end = 0;//geshu
48.     if((stream->flag & FFLUSH_LINE) && (num > 0))//问题在这，个数用num
49.         for(size_t i = stream->end; i < stream->end + num; i++)
50.            // if(stream->buffer[i] == '\\' && stream->buffer[i + 1] == 'n')
51.             if(stream->buffer[i] == '\n')
52.                 last_end = i + 1;
53.     printf("%d\n", last_end);
54.     stream->end = stream->end + num - last_end;
55.     printf("%s\n\n", stream->buffer);
56.     if(last_end)
57.     {
58.         write(stream->fileno, stream->buffer, last_end);
59.         memmove(stream->buffer, stream->buffer + last_end, stream->end);
60.     }
61.     return 0;
62. }
64. int my_fflush(myFILE* stream)
65. {
66.     if(stream->end > 0)
67.     {
68.         write(stream->fileno, stream->buffer, stream->end);
69.         stream->end = 0;
70.     }
71.     return 0;
72. }
74. int my_fclose(myFILE* stream)
75. {
76.     my_fflush(stream);
77.     return close(stream->fileno);
78. }

复制代码

实行目的

• 模拟缓冲区是怎么刷新的
  
• 模拟实现行刷新，办理代码问题和逻辑问题
  
• 更好理解缓冲区的实现
  

函数解释

my_fclose

• 就是一点：关闭之前，要刷新缓冲区
  

my_fflush

• 调用这个函数的时候，假如stream->end不为0，就是缓冲区里有有效值，刷新
  
• 刷新之后记得清0 stream->end
  

my_fwrite

逻辑

• 将self buffer 拷贝到 C buffer里
  
• 检查新拷贝的内容是否有\n
  
• 更新stream->end
  
• 刷新缓冲区
  
• 拷贝没有被刷新的内容
  

碰到的问题

• 遍历：我写的着实不必要num>0这个条件了，因为下面的for循环检查越界了；在此之前我写的是stream->end>0，这就导致第一次的abcde不会输出，因为stream->end这时候为0；bug就在这，我写的这个逻辑中第一次的stream->end并不代表个数
  
• stream->end更新的位置：开始是放在if(last_end)里，这样肯定不对！因为不刷新的时候，stream->end也要更新啊
  

总结

• 刷新方式比较重要
  
• 弄清晰样例
  
• 创建子历程时候，缓冲区是同一个，历程退出时候，会发生写实拷贝
  
• FILE布局体有维护缓冲区的字段
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。