前言
作者:小蜗牛向前冲
名言:我可以接受失败,但我不能接受放弃
如果觉的博主的文章还不错的话,还请点赞,收藏,关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正
本期学习目标:认识什么是缓冲区,缓冲区在哪里,模拟实现一个简单的缓冲区。
目录
一、缓冲区
1、见一个现象
2、缓冲区的相关知识
3、解释现象
二、模拟实现缓冲区
1、makefile
2、myStdio.h
3、myStdio.c
4、test.c
一、缓冲区
我们在重定向博客中曾经发现了一个现象,在做重定向实验时,我们将文件描述符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的接口进行强制刷新。