一、缓冲区
我们在重定向博客中曾经发现了一个现象，在做重定向实验时，我们将文件描述符fd = 1关闭掉，并通过open函数打开（创建）add.txt的文件，由于fd = 1 被关闭了，根据文件描述符fd的分配规则：是从小到大 ，遵循寻找最小而且没有被占用的的fd分配。这时候fd = 1中file*的指针会指向add.txt文件中，就不在向显示器打印了，而要将open fd的内容写到add.txt中，但是我们通过cat命令查看add.txt中的内容却什么也没有，这是为什么呢？
这就不得不提缓冲区的概念，其实缓存区就是一段内存，但是这段内存是谁申请的？属于谁的？为什么要有缓冲区呢？
下面我们来看一个现象:
1、见一个现象
首先我们分别调用C接口和系统接口进行打印测试。
我们将mytest中的文件内容输出重定向到log.txt中，我们也在log.txt中查找到了输出的内容.
下面我们继续进行在代码测试，在代码最后用fork建立一个子进程
运行程序：
我们发现 printf 和 fprintf及fputs（库函数）都输出了2次，而 write 只输出了一次（系统调用）。为什么呢？我们只是在多加了应该子进程而已，这说明出现这种现象肯定是和fork函数有关。
2、缓冲区的相关知识
为什么库函数会打印二次，而系统调用的函数只会被打印一次呢？毋庸置疑这肯定和缓冲区有关。
上面我们提到缓存冲区是一段内存，那么既然是一段内存肯定要被管理起来，而管理缓冲区的结构体我们称之为FILE,而且我们可以知道是缓冲区肯定不在内核中。
我们也可以在系统中见一见他
//输入命令 vim /usr/include/libio.h
打开文件在246行这样就能看到_IO_FILE的结构体，不对啊吖，不是说FILE才是管理缓冲区的吗？ 
怎么变成了_IO_FILE的结构体,其实在其实是在：
typedef struct _IO_FILE FILE; 在/usr/include/stdio.h
中进行了重命名的，第48行就对_IO_FILE的结构体进行了typedef。
这里我们需要注意的是FILE结构体中也封装了fd，这就会在合适的时候，就会将在缓冲区中内容刷新到外设中。
缓冲区的刷新几种形式：
立刻刷新 -----无缓冲
行刷新 ------显示器
缓冲区满刷新 -------磁盘文件
那我们怎么理解上面的几种刷新方式呢?
立刻刷新是只直接在内存中的信息，刷新到外设，这种场景是非常少见的，因为这样非常消耗资源。
行刷新，就是缓冲区满了一行就刷新，也就是说我们在调用函数时有"\n"时就会进行刷新。
缓冲区满刷新，就是指缓冲区的内存满了，才会把缓冲区里面的内容刷新到外设中。
缓冲区的自动刷新规则：
- 用户强制刷新
- 进程退出
3、解释现象
上面我们了解有关缓冲区的相关知识，那么为什么会出现我们上面的现象呢？
在代码结束前我们进行了子进程的创建：
代码结束之前，进行创建子进程
1. 如果我们没有进行>,看到了4条消息
stdout 默认使用的是行刷新，在进程fork之前，三条C函数已经将数据进行打印输出到显示器上(外设),你的FILE内部，进程内部不存在对应的数据啦。
2. 如果我们进行了>, 写入文件不再是显示器，而是普通文件，采用的刷新策略是全缓冲，之前的3条c显示函数，虽然带了\n,但是不足以stdout缓冲区写满！数据并没有被刷新！！！
执行fork的时候，stdout属于父进程，创建子进程时， 紧接着就是进程退出！谁先退出，一定要进行缓冲区刷新(就是修改)
由于写时拷贝！！数据最终会显示两份，所以在父子进程退出后，会立刻被缓冲区刷新，从而导致三条C函数分别进行了二次打印。
3. write为什么没有呢？
上面的过程都和wirte无关，wirte没有FILE，而用的是fd，就没有C提供的缓冲区
这里我们就可以回答：
缓冲区在哪里：
在FILE*指向的FILE结构体中(这也就是为什么，我们自己要强制刷新的时候要传文件指针,fflush(文件指针)，fclose（文件指针）)。
重定向实验的现象:
因为我们虽然将open fd的内容要写入到add.txt中，但是由于add.txt是普通文件，他采取的方式是全缓存，就不足以以让缓冲区刷新到显示器(stdout）中，所以通过cat 命令查看会什么也查不出来。
二、模拟实现缓冲区
这里我们分模块化实现：
1、makefile
这里我们用makefile来完成对程序的自动化编译和构建程序：
test:test.c myStdio.c //依赖关系 gcc -o $@ $^ -std=c99//依赖方法 .PHONY:clean//声明伪目标clean clean: rm -f test
2、myStdio.h
在myStdio.h中对 缓冲区结构进行定义并且进行相关的函数声明：
#pragma once #include <assert.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #define SIZE 1024 #define SYNC_NOW 1//sync能够马上刷新缓冲区（马上刷新） #define SYNC_LINE 2//行刷新 #define SYNC_FULL 4//全缓冲刷新 typedef struct _FILE{ int flags; //刷新方式 int fileno; int cap; //buffer的总容量 int size; //buffer当前的使用量 char buffer[SIZE]; }FILE_; FILE_ *fopen_(const char *path_name, const char *mode); void fwrite_(const void *ptr, int num, FILE_ *fp); void fclose_(FILE_ * fp); void fflush_(FILE_ *fp)
3、myStdio.c
在myStdio.c中对 缓冲区功能函数进行实现:
这里我们主要实现:
fopen_打开文件。fwrite_x向文件中写入，fflush_刷新缓冲区,fclose_关闭文件
#include "myStdio.h" FILE_ *fopen_(const char *path_name, const char *mode) { int flags = 0; int defaultMode=0666; 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 { //TODO } int fd = 0; if(flags & O_RDONLY) fd = open(path_name, flags); else fd = open(path_name, flags, defaultMode); if(fd < 0) { const char *err = strerror(errno); write(2, err, strlen(err)); return NULL; // 为什么打开文件失败会返回NULL } FILE_ *fp = (FILE_*)malloc(sizeof(FILE_)); assert(fp); fp->flags = SYNC_LINE; //默认设置成为行刷新 fp->fileno = fd; fp->cap = SIZE; fp->size = 0; memset(fp->buffer, 0 , SIZE); return fp; // 为什么你们打开一个文件，就会返回一个FILE *指针 } void fwrite_(const void *ptr, int num, FILE_ *fp) { // 1. 写入到缓冲区中 memcpy(fp->buffer+fp->size, ptr, num); //这里我们不考虑缓冲区溢出的问题 fp->size += num; // 2. 判断是否刷新 if(fp->flags & SYNC_NOW) { write(fp->fileno, fp->buffer, fp->size); fp->size = 0; //清空缓冲区 } else if(fp->flags & SYNC_FULL) { if(fp->size == fp->cap) { write(fp->fileno, fp->buffer, fp->size); fp->size = 0; } } else if(fp->flags & SYNC_LINE) { if (strcmp(&(fp->buffer[fp->size - 1]), "\n") == 0) { write(fp->fileno, fp->buffer, fp->size); fp->size = 0; } } else{ } } void fflush_(FILE_ *fp) { if( fp->size > 0) write(fp->fileno, fp->buffer, fp->size); fsync(fp->fileno); //将数据，强制要求OS进行外设刷新！ fp->size = 0; } void fclose_(FILE_ * fp) { fflush_(fp); close(fp->fileno); }
4、test.c
#include "myStdio.h" #include <stdio.h> int main() { FILE_ *fp = fopen_("./hello.txt", "w"); if(fp == NULL) { return 1; } int cnt = 10; const char *msg = "hello pjb "; while(1) { fwrite_(msg, strlen(msg), fp); sleep(1); printf("count: %d\n", cnt); cnt--; if(cnt == 0) break; } fclose_(fp); return 0; }
下面写一个简单的bush脚本：
while :; do cat hello.txt;sleep 1;echo "###############";done
这是一个简单的 Bash 脚本，它的功能是循环读取并打印文件 "hello.txt" 的内容，并每隔 1 秒打印一条分隔线。
解释一下脚本的含义：
while :; do表示开始一个无限循环。cat hello.txt使用cat命令读取并打印 "hello.txt" 文件的内容。sleep 1表示暂停执行 1 秒，即等待一秒钟。echo "###############"打印一条分隔线，由多个 "#" 字符组成。done表示循环结束。
因此，执行这段脚本时，会不断循环读取并打印 "hello.txt" 文件的内容，每次打印之间会有一秒的暂停，并且在每次打印后会输出一条分隔线。
请确保当前目录下存在名为 "hello.txt" 的文件，并且具有可读权限。
测试：
1、当写入文件的msg字符串不带换行符时。
const char *msg = "hello pjb ";
这里我们观察到当程序结束时，才将缓冲区中的内容刷新到hello.txt文件中。
2、当写入文件的msg字符串带换行符
const char *msg = "hello pjb\n";
这里名为可以验证到带\n普通文件是逐行进行刷新的。
缓冲区总结 ：
看到这些现象我们不由的想缓存区的刷新策略：有全缓存，行缓冲，立即刷新。
上面是我们自己进行的封装，但是这和os（操作系统）有什么关系呢?下面来看一幅图
这幅图大致说明了字符串，要写入到文件中，需要经过层层拷贝在 最终由操作系统(OS)决定刷新到磁盘文件中。
这里我们要注意的是，在有用户刷新到C语言的缓冲区(FILE)中才会遵循全缓冲，行缓冲。对于操作系统来说他会自己调配资源进行刷新。
特别注意：
我们也可以强制OS刷新，调用fflush()就可以了。
ffush（）的底层：
void fflush_(FILE_ *fp) { if( fp->size > 0) write(fp->fileno, fp->buffer, fp->size); fsync(fp->fileno); //将数据，强制要求OS进行外设刷新！ fp->size = 0; }
其实是调用来fsync的接口进行强制刷新。
![[Linux打怪升级之路]-信号的产生](https://ucc.alicdn.com/pic/developer-ecology/6v24jawhpy3hi_e2965e4493474952800c47457bc27ef4.png?x-oss-process=image/resize,h_160,m_lfit)
![[Linux打怪升级之路]-system V共享内存](https://ucc.alicdn.com/pic/developer-ecology/6v24jawhpy3hi_fe640bda8b1548fe9a8501c53ca11328.png?x-oss-process=image/resize,h_160,m_lfit)
