友链网站,天猫商城官网首页,网站怎么申请支付宝接口,如何给网站做备份前言
文件系统
我们先来看两个例子#xff1a; 这个程序输出#xff1a; 此时的输出也满足的我们预期。 我们也可以把 程序执行结果#xff0c;输出重定向到 一个文件当中: 当我们在代码的结尾处#xff0c;创建了子进程#xff0c;那么输出应该还是和上述是一样的 这个程序输出 此时的输出也满足的我们预期。 我们也可以把 程序执行结果输出重定向到 一个文件当中: 当我们在代码的结尾处创建了子进程那么输出应该还是和上述是一样的 此时我们把 这个程序的输出结果 重定向到 一个文件当中为了验证所以我们把之前在文件当中保存的 数据先删除 然后在进行重定向操作其实 这个重定向本来就可以做到 清空文件的作用这里只不过是 为了 分步骤来看更加可观 发现此时的结果在文件当中输出和之前不一样了。 上述的输出结果看上去和之前的输出结果没什么关系也不是单纯的输出了两遍因为只输出了 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函数之时比如 close1就会把 1 号文件 对应的 文件缓冲区当中的数据 刷新 到磁盘当中。 但是我们并没有看到 输出结果。 那么 语言层级的 函数不直接向 系统级别的 缓冲区当中写入数据那么数据究竟被写入到那里了呢 其实像 C/C 语言是有自己的 语言层级的 缓冲区 的。这个缓冲区是 用户级别的 缓冲区。 所以像 printf / fprintf / fwrite / fputs ····· 这些函数 在向文件当中写入数据之时并不是直接把数据写到 系统级别的缓冲区当中而是先写入到 语言层级的 缓冲区 当中。 只有当在 合适时机比如 遇到了强制刷新缓冲区fclose函数或者是在字符串当中有 \n ····· 等等时机此时 才会调用 write函数把 语言层级的 缓冲区 当中的数据写入到 系统缓冲区当中。 所以在 开始 close1关闭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函数封装的一个 函数 fflushstrout _exit() 他能看到 这个层次 C语言缓冲区。而 _exit() 不能刷新 C语言缓冲区是因为 _exit是底层系统调用接口它的层级是在底层它看不到 在用户层级的 C语言缓冲区。 所以到现在你可以简单 理解的为只要是 数据被刷新到 系统缓冲区当中了也就是 数据被刷新到了内核当中数据就可以到达硬件了。 缓冲区的刷新问题 主要分为三种方式进行刷新
无缓冲 --- 直接进行刷新也就是收到数据就马上把这个数据给刷新出去。比如调用 prinf函数调用 printf函数结束 就 立即把 缓冲区当中的数据刷新 到内核当中。行缓冲 --- 就像上述的 显示器文件一样一行一行的进行输出。不管当前缓冲区当中有多少个数据只要没有 \n 类似的换行符就会一直在 缓冲区当中等待只要 缓冲区当中读到了第一个 \n 类似的换行符才会把 缓冲区当中的 数据刷到 内核当中。 、全缓冲 --- 什么都不认无论输入什么数据到 缓冲区当中都要进行等待直到 把 缓冲区当中的数据写满了才会把 缓冲区当中的数据 刷新到 内核当中。 在文件缓冲区当中使用的刷新方式是 全缓冲也就是把缓冲区当中写满才会 把数据写到 文件缓冲区当中。
为什么文件要使用 全缓冲呢因为除了 显示器文件其他在磁盘当中存储的文件不是直接拿给 用户 或者是 操作系统来直接查看的。没有 显示器文件那种需求。
当然当进程退出之时也就刷新 C 语言缓冲区。像我们在 调用 printfhello Linux!; 在这个语句当中是没有 \n 的但是在最后还是会给我们刷新到 strout 文件当中让我们看到。
就是因为 当进程退出的之时也会刷新缓冲区。
所以缓冲区当中的刷新不一样必须按照上述的 三种方式来刷新。 为什么在 语言 层面会多出一个 语言层面的缓冲区呢
其实在语言层面的缓冲区就跟 快递公司一样当我们先寄出一个包裹的时候只需要到快递公司把信息填好快递公司就可以帮我们把东西送到目的地。
如果没有快递公司那么我们可能就要自己亲自去送到 目的地那么在此期间就会非常的耗费时间。
有了快递公司我们可以很方便的 把 送东西这个操作交给快递公司来做而我们就可以去干自己的事情。 快递公司在此处就相当于是 语言缓冲区它解决的事 程序运行的效率问题。注意解决的不是 操作系统当中的效率而是程序自己在运行之时的效率问题这个数据要 放到那个 文件当中该怎么放入走什么流程还是上述所说的流程只不过把这个流程不用程序自己做了交给 语言缓冲区来做就可以了。所以提高的是程序的运行效率。 所以我们调用 printf/ fprintf···· 这些需要向文件当做写入 数据的 函数才能很快的就调用个完。 要不是在用户层面要想访问到 底层当中硬件设备中间必须要 一层一层往下去调用接口来实现如果都交给 这个函数来完成的话程序的效率就会下降。 所以直接把要输入到 文件当中的数据直接放到 语言缓冲区当中交给他自己来判断当前的输入的数据当中是否 又要刷新的提示字符在合适时机来进行刷新。 同样语言层面的缓冲区 和 快递公司也是一样的如果你发一个快递就把 这个人的快递利用 货车或者是 飞机之类的方式直接送到目的地那不得亏死。
所以肯定是把 很多人的快递一块发送这样才省力。
在 缓冲区当中就有这么 多种刷新的方式但是都不是 来一个 数据比如来一个 char 类型的数据就把这个数据直接发送出去而是都是多个数据一起发送。 我们在使用 printf类似的函数之时 在C语言当中我们把这些函数称之为 -- 格式化输入输出函数。 因为 strout 本质上其实是一个文件在文件当中只能存储字符串所以我们在 显示器上看到的 输出的数据了其实就是字符串。 而上述函数在输出之时像 int a 100 ; printfhello %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.hstruct _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 putbackget 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 0int _blksize;
#elseint _flags2;
#endif_IO_off_t _old_offset; /* This used to be _offset but its too small. */
#define __HAVE_COLUMN /* temporary */
/* 1column 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 当中 在各个 系统调用接口基础之上来实现的 封装的 fopenfwrite···· 这些函数如果我们在 windowsmac 等等其他的 操作系统当中。
虽然上述的 不同操作系统当中 这些系统调用接口肯定是不一样的但是如果都在这些系统当中进行了封装以 条件编译的 形式如 #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指针说明打开文件失败elsereturn NULL;// 同样如果 open函数返回 -1 说明 open函数打开文件失败。返回 NULLif (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 是定义的宏当前默认是 1024if (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 4typedef 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.txtint 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;
}
