缓冲区
首先, 我们对缓冲区最基本的理解, 是一块内存, 用户提供的缓冲区就是用户缓冲区, C标准库提供的就是C标准库提供的缓冲区, 操作系统提供的就是操作系统缓冲区, 它们都是一块内存.
为什么要有缓冲区?
先举个生活中的例子, 我们寄快递的时候往往是去驿站寄快递, 而不是直接自己去送, 自己送效率太低, 不如直接把快递交给驿站. 驿站方便了用户, 虽然最终快递还是要被快递员送过去, 但是它给使用者提供了方便, 谁要寄快递就方便了谁.
驿站就相当于缓冲区:
1. 缓冲区的主要作用是提高效率, 提高使用者的效率, 谁使用缓冲区就提高谁的效率. 冯诺依曼体系中, 数据不用从一个设备拷贝到另一个设备, 而是把数据直接写入内存中, 让操作系统定期去刷新即可.
2. 因为有缓冲区的存在, 我们可以把数据积累一部分再统一发送, 提高了发送的效率.
缓冲区刷新方式
缓冲区因为能够暂存数据, 所以必定要有对应的刷新方式:
一般策略:
1. 无缓冲(立即刷新)
2. 行缓冲(行刷新)
3. 全缓冲(缓冲区满刷新)
特殊情况 :
1. 强制刷新
2. 进程退出的时候, 一般要进行刷新缓冲区
一般情况, 对于显示器文件, 行缓冲; 磁盘上的文件, 全缓冲.
现在看一个样例, 调用三个C语言接口往显示器打印, 再调用一个系统调用接口往显示器打印, 最后创建了一个子进程:
1 #include <stdio.h>
2 #include <string.h>
3 #include <unistd.h>
4 int main()
5 {
6 fprintf(stdout, "C: hello fprintf\n");
7 printf("C: hello printf\n");
8 fputs("C: hello fputs\n",stdout);
9 const char* str = "system call: hello write\n";
10 write(1,str,strlen(str));
11
12 fork();
13 return 0;
14 }
运行后发现结果和我们预想的一样, 打印了四条语句.
当我们向显示器打印的时候, 显示器的刷新方式是行刷新, 而代码中输出的语句都带有\n, fork之前, 数据全部被刷新, 包括系统调用.
现在把内容重定向到 log.txt 磁盘文件中 , 发现除了系统调用以外, 每一个C语句都被打印了两次:
重定向到 log.txt, 本质是向磁盘文件中写入, 系统对于数据的刷新方式变成了全刷新, 全刷新意味着缓冲区变大, 实际写入的几条简单数据不足以把缓冲区填满, 也就是说fork执行的时候, 数据依然在缓冲区中.
由于C语言printf等接口底层是封装了系统调用的, 而系统调用却没有打印两次, 说明目前我们谈的缓冲区和操作系统无关, 是C语言提供的缓冲区. C/C++提供的缓冲区, 里面保存的是用户的数据, 仍然属于当前进程在运行时自己的数据, 而进程退出的时候, 一般要刷新缓冲区, 即使数据没有满足刷新条件, 此例中不管是fork创建的子进程还是父进程, 总有一个进程要退出, 也就是会发生一次缓冲区刷新, 而刷新缓冲区是数据清空的操作, 就会发生写时拷贝! 另一个进程退出时数据还会被刷新一次, 数据就被刷新了两次.
再来解释一下为什么write的内容只显示了一次, 因为write是系统调用, 没有使用C缓冲区, 而是直接把数据写入到了操作系统, 如果我们把数据交给了操作系统, 数据就属于操作系统, 不属于当前进程了, 也就不会被写时拷贝.
什么叫做刷新?
我们printf将数据输入到C语言缓冲区中, 缓冲区满足刷新方式时就会调用write进行刷新, 刷新其实就是将数据从C缓冲区写入OS!
printf只在用户层与C缓冲区交互, 是用户级别的交互, 而不是直接将数据写入操作系统管理的文件缓存区中, 等C语言缓冲区存放了一定的数据后再统一刷新到文件缓冲区, 文件缓冲区再刷新到磁盘中, 提高了printf的效率, 从而间接提高了程序其它代码执行的效率. 另外, 其实printf在拷贝字符串数据的同时也把格式化%d等操作拷贝到目标字符串中, 顺便也把格式化输出的工作也做了.
操作系统管理的文件缓冲区也有自己的刷新方式, write系统调用只管把C缓冲区的数据写到文件缓冲区即可, 不关心它什么时候刷新到磁盘, 这样能提高系统调用的效率.
C语言缓冲区在哪里?
C语言缓冲区存在FILE结构体里, FILE结构体里不仅封装了fd, 而且包含了该文件fd对应的语言层的缓冲区结构_IO_FILE, 在/usr/include/libio.h中:
模拟实现C标准库的函数
这里目的是代码说明, 不是复刻
mystdio.h
#pragma once
#define SIZE 4096
#define FLUSH_NONE 1
#define FLUSH_LINE (1<<1)
#define FLUSH_ALL (1<<2)
typedef struct _FILE
{
int fileno;//文件标识符
int flag;//刷新策略
char buffer[SIZE];//缓冲区
int end;//缓冲区大小
} my_FILE;
extern my_FILE* my_fopen(const char* path, const char* mode);
extern int my_fclose(my_FILE* stream);
extern int my_fflush(my_FILE* stream);
extern unsigned my_fwrite(const void* ptr, unsigned num, my_FILE* stream);//fwrite中间两个参数简化为1个
mystdio.c
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#define DEFAULT_MODE 0666
my_FILE* my_fopen(const char*path, const char* mode)
{
int fd = 0;//文件描述符
int flag = 0;//确定打开方式
if(strcmp(mode,"r") == 0)
{
flag |= O_RDONLY;
}
else if(strcmp(mode,"w") == 0)
{
flag |= O_CREAT | O_TRUNC | O_WRONLY;
}
else if(strcmp(mode,"a") == 0)
{
flag |= O_CREAT | O_APPEND | O_WRONLY;
}
if(flag & O_CREAT)
fd = open(path, flag,DEFAULT_MODE);
else
fd = open(path, flag);
if(fd < 0)
{
errno = 2;
return NULL;
}
//创建一个my_FILE结构体
my_FILE* stream = (my_FILE*)malloc(sizeof(my_FILE));
if(!stream)
{
errno = 3;
return NULL;
}
stream->fileno = fd;
stream->end = 0;
stream->flag = FLUSH_LINE;
return stream;
}
int my_fflush(my_FILE* stream)
{
if(stream->end > 0)
{
write(stream->fileno, stream->buffer, stream->end);
stream->end = 0;
}
return 0;
}
int my_fclose(my_FILE* stream)
{
my_fflush(stream);//文件关闭前刷新缓冲区
int ret = close(stream->fileno);
if(ret)
errno = 2;
return ret;
}
unsigned my_fwrite(const void*ptr, unsigned num, my_FILE* stream)
{
memcpy(stream->buffer+stream->end,ptr,num);
//判断是否需要行刷新
if(stream->end > 0 && stream->flag & FLUSH_LINE)
{
unsigned i = 0;
for(i = 0; i < num; i++)
{
if(*(stream->buffer+stream->end+i) == '\n')
{
stream->end += num;
my_fflush(stream);
return 0;
}
}
}
stream->end += num;
return stream->end;
}
main.c , 用于测试:
#include "mystdio.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
my_FILE* fp = my_fopen("log.txt","w");
if(fp == NULL)
{
perror("fopen");
return 1;
}
const char* msg = "hello, mystdio\n";
int cnt = 20;
while(cnt--)
{
my_fwrite(msg,strlen(msg),fp);
sleep(1);
}
my_fclose(fp);
return 0;
}
编译:
运行结果:
总结:
不管是什么语言Java, python, C, C++等, 它们的IO函数上层的接口使用起来都不一样, 但是它们的底层都是一样的, 操作系统决定了它们的底层必须一样, 不管上层的接口如何封装如何设计, 底层都是一样的.