Linux - 用户级缓冲区和系统缓冲区 - 初步理解Linux当中文件系统

前言

文件系统

我们先来看两个例子：

这个程序输出：

此时的输出也满足的我们预期。

我们也可以把程序执行结果，输出重定向到一个文件当中:

当我们在代码的结尾处，创建了子进程，那么输出应该还是和上述是一样的：

此时，我们把这个程序的输出结果 ">" 重定向到一个文件当中，为了验证，所以，我们把之前在文件当中保存的数据先删除：

然后，在进行重定向操作（其实 ">" 这个重定向本来就可以做到清空文件的作用，这里只不过是为了分步骤来看，更加可观）：

发现，此时的结果，在文件当中输出和之前不一样了。

上述的输出结果，看上去和之前的输出结果没什么关系，也不是单纯的输出了两遍，因为只输出了 7 行而不是 8 行。

我们发现，除了 write（）系统调用接口函数之外，C 库当中都是按照我们调用的顺序调用了两遍。而且，wirte（）函数的打印顺序，和之前相比也是不一样的。

说明，系统调用接口，没有受到我们 fork（）函数影响。

出现上述的原因，就和 缓冲区脱不了干系了。

缓冲区

先看下述例子：

上述的三个函数都是在 stdout 这个文件当中输出数据，当他们输出完毕之后，我再去把 1 号文件也就对应着 stdout 这个文件关闭了，然后程序执行结束，你再猜猜此时的输出结果是什么？

发现，此时是什么结果都没有输出的，同样，重定向到 log.txt 文件当中也是没有输出的。

上述的是 3 个 C库函数，如果是系统调用接口呢？此时我们把 write（）系统调用接口调用：

输出：

发现居然 成功输出 了。

在 C 当中封装的要调用到硬件的函数，底层都是要调用系统调用接口的，比如上述的函数，都是要调用 write（）函数的。

都是把对应的数据，传入到 write（）系统调用接口，然后通过系统调用接口来输入到缓冲区当中。

其实，上述使用的 3 个C库函数，其实是已经在缓冲区当中输入数据了的。

一个文件，肯定是提供了自己操作系统级别的缓冲区。这个缓冲器就是这个文件的 文件缓冲区。

但是，3 个C库函数 写入的缓冲区肯定不是系统级别的缓冲区，如果是系统级别的缓冲区的话，程序执行结束之时，就会刷新缓冲区，我们就会看到对应的输出结果。

这就是为什么 write（）系统调用接口可以看到输出结果。write（）函数，是直接向传入的文件的对应文件缓冲区当中写入数据。到最后刷新文件缓冲区之时，就会把数据刷新到文件当中。

而且，像 printf / fprintf / fwrite / fputs ····· 这些函数，不是直接向文件缓冲区当中去刷新数据，因为文件缓冲区是属于内核的，在语言级别封装的函数是不能直接访问到的，中间还有层级。（反证：如果 printf / fprintf / fwrite / fputs ····· 这些函数已经把数据拷贝到文件缓冲区当中了，当我们调用 close（）函数之时，比如 close（1），就会把 1 号文件对应的文件缓冲区当中的数据刷新到磁盘当中。但是，我们并没有看到输出结果。）

那么，语言层级的函数，不直接向系统级别的缓冲区当中写入数据，那么数据究竟被写入到那里了呢？

其实，像 C/C++ 语言，是有自己的 语言层级的缓冲区 的。这个缓冲区是 用户级别的缓冲区。

所以，像 printf / fprintf / fwrite / fputs ····· 这些函数在向文件当中写入数据之时，并不是直接把数据写到系统级别的缓冲区当中，而是先写入到 语言层级的缓冲区 当中。

只有当在合适时机，比如遇到了强制刷新缓冲区，fclose（）函数，或者是在字符串当中有 '\n' ····· 等等时机，此时才会调用 write（）函数把 语言层级的缓冲区 当中的数据，写入到系统缓冲区当中。

所以，在开始 close（1）关闭1号文件 C 库函数没有输出的原因是：

在 C语言当中的缓冲区刷新之前，1 号文件也就是 stdout 文件已经被关闭了，当程序解释之时， C语言当中的缓冲区想要刷新其中的数据到 1 号文件的文件缓冲区之时，在这个进程当中就找不到这 1 号文件了。

所以，此时如果我们把三个 C库函数当中要输出的字符串都，就可以输出数据了。

输出：

为什么在字符串当中 带上 '\n' 的话 就可以刷新呢？

因为 显示器文件的刷新方案是行刷新。所以在类似 printf（）函数执行之时，识别到字符串当中有 '\n' ，遇到 '\n' 就会立即把 C语言缓冲区当中的数据刷新出去。

所以，刷新的本质就是通过 1 号文件 + write（）系统接口的方式，写入到内核当中的系统级别的缓冲区当中。

所以，例如 exit（） 和 _exit（）两个函数是有区别的！！

exit（）是C当中通过 _exit（）函数封装的一个函数，而 _exit（）此时真正实现进程退出的系统调用接口；exit（）底层当中一定有_exit（）的调用。

在理解上述用户级别缓冲区和操作系统级别的缓冲区的区别之后，你应该就会明白这两个函数有什么不同。

之所以 exit（）函数能刷新 C语言缓冲区，是因为 exit（）函数是在 C语言当中通过 _exit（）函数封装的一个函数（ fflush（strout）； _exit() ），他能看到这个层次 C语言缓冲区。而 _exit() 不能刷新 C语言缓冲区是因为 _exit（）是底层系统调用接口，它的层级是在底层，它看不到在用户层级的 C语言缓冲区。

所以，到现在，你可以简单理解的为：只要是数据被刷新到系统缓冲区当中了，也就是数据被刷新到了内核当中，数据就可以到达硬件了。

缓冲区的刷新问题

主要分为三种方式进行刷新：

无缓冲 --- 直接进行刷新，也就是收到数据就马上把这个数据给刷新出去。比如调用 prinf（）函数，调用 printf（）函数结束就立即把缓冲区当中的数据刷新到内核当中。
行缓冲 --- 就像上述的显示器文件一样，一行一行的进行输出。不管当前缓冲区当中有多少个数据，只要没有 '\n' 类似的换行符，就会一直在缓冲区当中等待，只要缓冲区当中读到了第一个 '\n' 类似的换行符，才会把缓冲区当中的数据刷到内核当中。、
全缓冲 --- 什么都不认，无论输入什么数据到缓冲区当中，都要进行等待，直到把缓冲区当中的数据写满了，才会把缓冲区当中的数据刷新到内核当中。

在文件缓冲区当中使用的刷新方式是 全缓冲，也就是，把缓冲区当中写满才会把数据写到文件缓冲区当中。

为什么文件要使用全缓冲呢？（因为，除了显示器文件，其他在磁盘当中存储的文件，不是直接拿给用户或者是操作系统来直接查看的。没有显示器文件那种需求。）

当然，当进程退出之时，也就刷新 C 语言缓冲区。像我们在调用 printf（"hello Linux!"）; 在这个语句当中是没有 '\n' 的，但是，在最后还是会给我们刷新到 strout 文件当中让我们看到。

就是因为当进程退出的之时，也会刷新缓冲区。

所以，缓冲区当中的刷新不一样必须按照上述的三种方式来刷新。

为什么在语言层面会多出一个语言层面的缓冲区呢？

其实，在语言层面的缓冲区就跟快递公司一样，当我们先寄出一个包裹的时候，只需要到快递公司，把信息填好，快递公司就可以帮我们把东西送到目的地。

如果没有快递公司，那么我们可能就要自己亲自去送到目的地，那么在此期间，就会非常的耗费时间。

有了快递公司，我们可以很方便的把 "送东西"这个操作，交给快递公司来做，而我们就可以去干自己的事情。

快递公司在此处就相当于是语言缓冲区，它解决的事程序运行的效率问题。注意解决的不是操作系统当中的效率，而是程序自己在运行之时的效率问题，这个数据要放到那个文件当中，该怎么放入，走什么流程，还是上述所说的流程，只不过，把这个流程不用程序自己做了，交给语言缓冲区来做就可以了。所以提高的是程序的运行效率。

所以我们调用 printf（）/ fprintf（）···· 这些需要向文件当做写入数据的函数，才能很快的就调用个完。

要不是，在用户层面，要想访问到底层当中硬件设备，中间必须要一层一层往下去调用接口来实现，如果都交给这个函数来完成的话，程序的效率就会下降。

所以，直接把要输入到文件当中的数据，直接放到语言缓冲区当中，交给他自己来判断当前的输入的数据当中是否又要刷新的提示字符，在合适时机，来进行刷新。

同样，语言层面的缓冲区和快递公司也是一样的，如果你发一个快递，就把这个人的快递，利用货车，或者是飞机之类的方式，直接送到目的地，那不得亏死。

所以，肯定是把很多人的快递一块发送，这样才省力。

在 缓冲区当中就有这么多种刷新的方式，但是都不是来一个数据比如来一个 char 类型的数据就把这个数据直接发送出去，而是都是多个数据一起发送。

我们在使用 printf（）类似的函数之时：

在C语言当中我们把这些函数称之为 -- 格式化输入输出函数。

因为 strout 本质上其实是一个文件，在文件当中只能存储字符串，所以，我们在显示器上看到的输出的数据了，其实就是字符串。

而，上述函数在输出之时，像 int a = 100 ; printf（"hello %d Linux!" , a); 当中的 "hello %d Linux!" 这个字符串是我们在函数当中使用的格式化输出的字符串的格式，要求在这个字符串当中的 "%d" 这个位置，替换为 a 变量的值。

而 a 变量是 int 类型，其实就是在 "%d" 这个位置把 a 变量的值，以字符串的形式替换到 "%d" 这个位置。

所以，其实在语言缓冲区当中，收到的就是这个经过格式化的字符串，

所以，语言缓冲区还有一个作用就是： 配合格式化输出。

像底层的操作系统级别的缓冲区，不需要给各种不同的语言来给这个缓冲区来指定不同的格式化输出的方法。

自己语言的格式化为字符串的方法，由自己的语言的缓冲区来提供和实现，操作系统级别的缓冲区只用做的是把上层缓冲区传入的字符串数据，保存到自己的缓冲区当中，然后刷新到对应文件当中。

所以，各种数据，结果各个接口，来到各个缓冲区当中之时，来的时候可能是多少多少字节的方式刷新到缓冲区当中的；而又是以多少多少字节的方式刷新到文件当中的。

这种方式不就像是流水一般，有近就有出；所以，我们把这个称之为 --- 文件流。

语言缓冲区在哪？

上述我们多次提到了语言缓冲区，那么这个缓冲区到底在哪呢？

在 C 当中，我们要像访问文件，对文件内容进行修改的话，离不开 C 当中的封装的一个结构体 -- FILE。

这个 FILE 本质其实就是一个结构体，在这个结构体当中封装了 fd 文件描述符。因为不管哪种语言，只要是想访问文件，就必须要按照操作系统当中访问文件的方式来访问 -- 就是使用 fd 文件描述符，通过文件描述符表当中的映射关系来找到这个文件对象，从而对文件进行访问。

实际上，FILE 当中封装的不只是上述的 fd文件描述符，还有上述所说的 语言缓冲区字段 和 维护这个缓冲区的信息。

所以，其实这个缓冲区就是在 FILE 这个结构体当中创建和维护的。

所以，在打开这个文件之后，如果我们先要利用某些函数来访问到这个文件的话，就需要找到这个 FILE，所以我们才要传入这个 FILE 的指针。

所以，如果我们现在打开的 10 个文件，那么就创建了 FILE 文件。

每一个像不同文件写入数据的操作，实际上就是，通过对应文件的 FILE 结构体当中的缓冲区当中的数据，把这个数据刷新到对应文件当中。

如下就是 FILE 结构体的定义（部分）：

Linux 当中是在/usr/include/stdio.h 默认是在这个路径下：

typedef struct _IO_FILE FILE; // 在/usr/include/stdio.h

//在/usr/include/libio.h

struct _IO_FILE {
    int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
//缓冲区相关
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
    char* _IO_read_ptr; /* Current read pointer */
    char* _IO_read_end; /* End of get area. */
    char* _IO_read_base; /* Start of putback+get area. */
    char* _IO_write_base; /* Start of put area. */
    char* _IO_write_ptr; /* Current put pointer. */
    char* _IO_write_end; /* End of put area. */
    char* _IO_buf_base; /* Start of reserve area. */
    char* _IO_buf_end; /* End of reserve area. */
    /* The following fields are used to support backing up and undo. */
    char* _IO_save_base; /* Pointer to start of non-current get area. */
    char* _IO_backup_base; /* Pointer to first valid character of backup area */
    char* _IO_save_end; /* Pointer to end of non-current get area. */
    struct _IO_marker* _markers;
    struct _IO_FILE* _chain;
    int _fileno; //封装的文件描述符
#if 0
    int _blksize;
#else
    int _flags2;
#endif
    _IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
    unsigned short _cur_column;
    signed char _vtable_offset;
    char _shortbuf[1];
    /* char* _save_gptr; char* _save_egptr; */
    _IO_lock_t* _lock;
#ifdef _IO_USE_OLD_IO_FILE
};

通过上述的说明，你就会知道，为什么open（）函数返回的是 FILE* ，在 open（）函数当中肯定是要类似 FILE* file = (FILE*)malloc(sizeof(xxx) * xxx); 这样创建一个 FILE 结构体对象的操作。

C 当中的 FILE 对象是属于用户？还是操作系统？

答案是属于用户的，所有的语言层面的，都是属于用户的。所以，我们把 FILE 当中的缓冲区，称之为用户级别的缓冲区。

理解开头例子（理解子进程当中继承的父进程当中的 FILE）

所以你就可以了理解上述的例子为什么会输出上述的结果了：

因为我们上述在进行输出的时候，使用了 ">" 这个重定向符号，我们知道，在上述例子当中的这个 ">" 其实实现就是把输出文件从 stdout 文件改为了 log.txt 文件。

那么，缓冲区的刷新方式 也从 显示文件的行刷新 转变到了 文件的全刷新。

也就是说此时，遇到 '\n' 不会再进行刷新。 只有当缓冲区当中的数据已经被写满了，才会去刷新。在不满的情况下，只有在进程结束才会刷新。

现在，我们再把下述程序的输出过程来证明一下：

上述程序输出：

为什么是 wirte（）先打印？

我们写一个简单的脚本来查看这个程序的运行过程，查看写入顺序：

脚本输出：

而在上述代码当中，是先把三个 C库函数调用完毕，然后再调用 write（）系统调用接口；
那么，程序只要是输出了 write（）函数输出的内容，说明上述的三个 C库函数已经调用完毕。那么为什么不输出三个 C库函数的输出结果呢？为什么是在后面输出呢？就是因为 这个三个 C库函数是往语言缓冲区当中输出的；而 write（）是直接往系统缓冲区当中输出的。
而且，在上述代码当中，三个 C库函数输出的字符串当中都带上了 '/n' 的，按照显示器文件，那么应该是一个C 库函数的输出，但是为什么上述是一起输出的呢？其实就是因为，当我们，重定向之后，输出文件变成了 log.txt 这个文件，这是普通文件，所以刷新方式是全刷新方式。

所以，在上述例子的基础之上，我们创建了子进程，输出如下所示：

其实就是因为:

缓冲区的刷新方式变成了全缓冲（在不满的情况下，只有在进程结束才会刷新），因为 write（）函数是直接往系统缓冲区当中刷新数据，所以，可以直接刷新到文件。

在父进程当中，write（）函数调用之前调用的三个 C库函数，已经被刷新到语言缓冲区当中的，但是因为是全刷新方式，所以，遇到 '\n'，没有刷新到系统缓冲区当中。

当子进程当中，虽然没有调用三个 C库函数，此时，对于 父子进程来说，他们共有一个代码和数据，也就是此时，父子进程共有一个 FILE 结构体对象，那么其中的缓冲区也是共有的。

但是，因为最后，当程序执行结束时，就要把缓冲区当中的数据刷新到系统缓冲区当中；对于父进程来说，把缓冲区当中内容刷新到系统缓冲区当中这个操作，不就相当于是把 FILE 当中的缓冲区字段清空了，这不就是修改操作吗？

所以，在父子进程当中，不管是谁修改了某一个数据，操作系统就会为这个进程进行写时拷贝。所以，此时，父子进程当中就有了 两个 FILE 结构体对象，也就有了 父子进程各自独有的缓冲区了。

也就是说，在最后把父子进程共有的缓冲区当中的数据刷新到系统缓冲区当中之时，对于父进程，缓冲区其实就是我们在堆上开辟出的空间，刷新到系统缓冲区这个操作，就是把这个堆上开辟空间存储的数据全部删除了，也就相当于是父进程对这个空间当中的数据进行了修改，所以要发生写时拷贝。

写时拷贝之后，父子进程就拥有各自的两个独立的 FILE 对象了，也就有两个独立的缓冲区了。

而，子进程当中缓冲区的数据还是之前三个 C库函数写入的数据，父进程也还是，所以，我们发现，在C 库函数当中输出的内容，在创建子进程之后，打印了两遍了。

而上述是因为 fork（）创建了子进程，而且，还使用了 ">" 把程序输出内容输出到文件当中，改变了刷新方式；

而，如果我们直接运行程序，不重定向到其他普通文件，就算我们创建了子进程，因为显示器文件是行刷新的，在上述例子当中每一个 C库函数当中的输出字符串当中就有 '\n' 字符，用于很刷新的判断。

所以，每调用完函数，就会检测到 '\n' 字符，直接就进行刷新了。

简单模拟实现 C 当中的 fopen（）等等函数

简单模拟实现，主要是理解 C 当中封装的系统调用接口，是如何进行调用的，当然，这里实现肯定是没有 Linux 当中 C 库函数写的好的，主要是帮助理解：

上述是在 Linux 当中，在各个系统调用接口基础之上来实现的，封装的 fopen（），fwrite（）···· 这些函数，如果我们在 windows，mac 等等其他的操作系统当中。

虽然上述的不同操作系统当中这些系统调用接口肯定是不一样的，但是，如果都在这些系统当中进行了封装，以条件编译的形式（如 #ifndef 宏），都放到C语言源代码当中，那么，不同的操作系统来调用，就可以把这些函数裁剪成是自己操作系统调用接口的代码（库）。

实现，在不同的平台下，实现封装的函数名相同，但是底层调用的系统调用接口不一样。

像上述就是适合于 Linux 当中的代码。

这就叫做，C语言具有跨平台性。

就像移植性非常强的 java，就是用 JVM java虚拟机实现的，java 的所有平台上的代码，都在 JVM 当中进行解释，所以我们在自己的本地机器当中，像运行一个 JAVA 程序，就要有 JVM JAVA 环境，运行 java 程序之前要启动虚拟机。

其实，本质上，底层 JVM 就是用 C/C++ 来实现的，运行 JVM 的本质就是用 C/C++ 可执行程序运行 JVM 进程。

在 JVM 当中，实现移植，就是用类似上述的方式，来切分出代码，哪一个操作系统应该使用哪一些系统调用接口，切分好，就执行那一部分代码。

而且，在系统调用层面上，是不管我们输入输出输入的是什么变量的，因为，不管是我们从键盘，文件当中地区数据到程序当中，变量接收；还是从程序当中写入数据到文件当中；在操作系统看来， 都是字符串。

由上图可以发现，接收的数据是以 void* buf 变量来接受的，不管传入的是什么类型的变量，都是以字符串的形式接受输入和输出的。

我们之所以能用变量去接收字符串当中某些数据，或者是把某些变量当中的数据输出到文件当中，这些操作，是由 scanf（）和 printf（）这些类似的格式化输入输出函数来帮我们格式化的输入输出数据的。

所以，键盘显示器这些设备，叫做 字符设备。而不叫做整数设备什么的。

所以，就和之前所说的 FILE 当中缓冲区存在的意义就是，让我们调用 C 的库函数更快，以为调用 write（）之类的函数，比如刷新数据到系统缓冲区当中是要花费时间的，所以，就攒一波数据，同一发送，把很多数据一起发送到缓冲区当中，就减少了IO的次数，提高了我们调用 fwrite（）等等库函数的效率。

所以，像全缓冲，看似是，如果我们没有写满语言缓冲区，那么就不会刷新，但是还是有其他情况可以强制刷新语言缓冲区当中数据，比如调用 fflush（）函数，或者是 close（）关闭文件。都会刷新缓冲区。

完整代码：

// Mystdio.c
#include "Mystdio.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

#define FILE_MODE 0666

// "w", "a", "r"
_FILE* _fopen(const char* filename, const char* flag)
{
    // 防止用户传入参数操作
    assert(filename);
    assert(flag);

    int f = 0;
    int fd = -1; 
    // 如果是以写的方式
    if (strcmp(flag, "w") == 0) {
        // 下述是库函数当中的 三个宏 ，代表的是 open（）当中读写方式的不同参数
        f = (O_CREAT | O_WRONLY | O_TRUNC);

        // 调用 open 系统调用接口
        fd = open(filename, f, FILE_MODE);
    }
    // 如果是以追加的方式
    else if (strcmp(flag, "a") == 0) {
        f = (O_CREAT | O_WRONLY | O_APPEND);
        fd = open(filename, f, FILE_MODE);
    }
    // 如果是以读的方式
    else if (strcmp(flag, "r") == 0) {
        f = O_RDONLY;
        fd = open(filename, f);
    }
    // 如果上述都不是，就返回 NULL指针，说明打开文件失败
    else
        return NULL;

    // 同样，如果 open（）函数返回 -1 ，说明 open（）函数打开文件失败。返回 NULL
    if (fd == -1) return NULL;

    // 这个是文件对象（注意：此处是 相当于是 C 当中的 FILE）
    _FILE* fp = (_FILE*)malloc(sizeof(_FILE));
    if (fp == NULL) return NULL;  // 防止 malloc 失败

    // 给 FILE当中的 成员赋值
    fp->fileno = fd;   // 文件描述符
    //fp->flag = FLUSH_LINE;
    fp->flag = FLUSH_ALL;  // 默认是 全缓冲的方式
    fp->out_pos = 0;       // 初始，FILE 当中的缓冲区是没有数据的

    return fp;
}

// FILE中的缓冲区的意义是什么？？？？
int _fwrite(_FILE* fp, const char* s, int len)
{
    // "abcd\n"
    // 把 
    memcpy(&fp->outbuffer[fp->out_pos], s, len); // 没有做异常处理, 也不考虑局部问题
    fp->out_pos += len;

    // 如果是 无缓冲
    if (fp->flag & FLUSH_NOW)
    {
        // 直接调用 wirte（）系统调用接口进行刷新
        write(fp->fileno, fp->outbuffer, fp->out_pos);
        fp->out_pos = 0;   // 刷新之后，FILE 当中的缓冲区不再有数据
    }
    // 如果是 行缓冲
    else if (fp->flag & FLUSH_LINE)
    {
        // 如果字符串末尾是  '\n'，不考虑中间有 '\n'，或者是 多个  '\n' 的情况
        // 简单实现
        if (fp->outbuffer[fp->out_pos - 1] == '\n') { // 不考虑其他情况
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;// 刷新之后，FILE 当中的缓冲区不再有数据
        }
    }
    // 如果是 全缓冲
    else if (fp->flag & FLUSH_ALL)
    {
        // SIZE 是定义的宏，当前默认是 1024
        if (fp->out_pos == SIZE) {
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;// 刷新之后，FILE 当中的缓冲区不再有数据
        }
    }

    return len;
}

// 封装 fflush（）函数，作用是刷新缓冲区
void _fflush(_FILE* fp)
{
    if (fp->out_pos > 0) {
        write(fp->fileno, fp->outbuffer, fp->out_pos);
        fp->out_pos = 0;
    }
}

void _fclose(_FILE* fp)
{
    // 特殊处理
    if (fp == NULL) return;
    _fflush(fp);  // 如果 当前缓冲区当中还有数据，就刷新缓冲区
    close(fp->fileno);   // 调用close 系统调用接口
    free(fp);            // 释放 FILE 结构体对象
}

//Mystdio.h
#ifndef __MYSTDIO_H__
#define __MYSTDIO_H__

#include <string.h>

#define SIZE 1024

#define FLUSH_NOW 1
#define FLUSH_LINE 2
#define FLUSH_ALL 4

typedef struct IO_FILE {
    int fileno;           // 封装 fd 文件描述符
    int flag;             //
    //char inbuffer[SIZE];
    //int in_pos;
    char outbuffer[SIZE]; // 缓冲区字段
    int out_pos;          // 维护缓冲区大小
}_FILE;

_FILE* _fopen(const char* filename, const char* flag);
int _fwrite(_FILE* fp, const char* s, int len);
void _fclose(_FILE* fp);


#endif


//main.c
#include "Mystdio.h"
#include <unistd.h>

#define myfile "test.txt"

int main()
{
    _FILE* fp = _fopen(myfile, "a");
    if (fp == NULL) return 1;

    const char* msg = "hello world\n";
    int cnt = 10;
    while (cnt) {
        _fwrite(fp, msg, strlen(msg));
        // fflush(fp);
        sleep(1);
        cnt--;
    }

    _fclose(fp);

    return 0;
}