Linux -- 文件【中】-EW帮帮网

# 读写文件时，如果不会开辟对文件操作的缓冲区，直接通过系统调用对磁盘进行操作(读、写等)，那么每次对文件进行一次读写操作时，都需要使用读写系统调用来处理此操作，即需要执行一次系统调用，执行一次系统调用将涉及到CPU状态的切换，即从用户空间切换到内核空间，实现进程上下文的切换，这将损耗一定的CPU时间，频繁的磁盘访问对程序的执行效率造成很大的影响。

# 为了减少使用系统调用的次数，提高效率，我们就可以采用缓冲机制。比如我们从磁盘里取信息，可以在磁盘文件进行操作时，可以一次从文件中读出大量的数据到缓冲区中，以后对这部分的访问就不需要再使用系统调用了，等缓冲区的数据取完后再去磁盘中读取，这样就可以减少磁盘的读写次数，再加上计算机对缓冲区的操作大大快于对磁盘的操作，故应用缓冲区可大大提高计算机的运行速度。

# 又比如，我们使用打印机打印文档，由于打印机的打印速度相对较慢，我们先把文档输出到打印机相应的缓冲区，打印机再自行逐步打印，这时我们的CPU可以处理别的事情。可以看出，缓冲区就是一块内存区，它用在输入输出设备和CPU之间，用来缓存数据。它使得低速的输入输出设备和高速的CPU能够协调工作，避免低速的输入输出设备占用CPU，解放出CPU，使其能够高效率工作。

2、用户级(语言)缓冲区

# 我们看之前写的一段代码：

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main()
{
    close(1);//关闭标准输出流
    int fd=open("log.txt",O_WRONLY|O_CREAT,0666);
    if(fd<0)
    {
        perror("open fail:");
        return 1;
    }

    //向屏幕打印信息
    printf("hello tata!\n");
    printf("hello tata!\n");
    printf("hello tata!\n");
    printf("hello tata!\n");
    printf("hello tata!\n");
    close(fd);

    return 0;
}

# 为什么没有打印信息呢？其实这就与我们C语言的缓冲区有关。

# 我们都知道操作系统内部会为每个文件创建一个文件内核缓冲区，而我们的库函数printf、fprintf、fput等，并不是直接把内容直接写到文件内核缓冲区里面，而是写入C语言标准库里面的语言级缓冲区里面。只有当我们的刷新条件满足时，才会把语言级别缓冲区的内容拷贝到文件内核缓冲区里面。

# 那他是如何拷贝到内核缓冲区的呢？答案是fd+write系统调用根据文件描述符找到对应文件缓冲区在通过系统调用write拷贝。

# 所以这就是为什么我们close(fd)后，库函数的内容没有写入log.txt文件里面。因为我们return前close(fd) ，而我们使用库函数并没有将字符串写入到内核缓冲区，而是保留在语言缓冲区。当进程退出时，语言缓冲区的内容会刷新到内核缓冲区，但是我们在return前关闭了文件描述符，而刷新要有fd+write，所以此时就找不到fd，导致内核缓冲区无法刷新。

# 那么我们的缓冲区是定义在哪的呢？

# 由于我们使用的printf是C语言提供的接口，所以这个缓冲区也是C语言提供的，其被包含在名为File的结构体中，不光是缓冲区，文件描述符fd也被包含在其中。这也是为什么C语言的文件接口需要返回File*的原因。

//在/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
};

3、缓冲类型

# 进程强制刷新就是我们手动刷新，进程退出后操作系统在我们程序结束后刷新，那刷新条件又是什么呢？

# 这就是缓冲区常见的三种刷新策略：

无缓冲。

行缓冲。（常见的对显示器进行刷新数据）

全缓冲。（常见的对磁盘文件写入数据）

# 刷新条件一般有这三种，那为什么C语言要提供缓冲区呢？

# 因为系统调用也是有成本的，malloc底层也是系统调用，所以我们vector扩容时扩2倍或1.5倍，就是为减少扩容次数，从而减少系统调用次数提高效率。所以我们有了语言缓冲区就可以把多次文件写入的内容通过一次系统调用刷新到内核缓冲区，减少系统调用的次数进而提高效率，否则我们写一次就需要一次系统调用。C++也是如此，所以C++不带endl刷新，也可能不会刷新。

# 我们的全缓冲效率是最高的，因为刷新的越多系统调用次数越少。所以我们的普通文件一般使用的是全缓冲，但是我们的显示器文件一般是行缓冲，所以我们printf是他会检测\n，如果有\n，他就会把\n之前的所有数据刷新到缓冲区上。如果没有加\n就是全缓冲，否则就是行缓冲。

# 为什么显示器要采用行刷新呢？因为行刷新更符合用户阅读习惯，否则一刷新一大片不利于阅读。同时内核缓冲区的刷新条件也是一样的，但是操作系统的刷新由操作系统自己决定，我们用户只要把数据交给操作系统，就相当于交给了硬件，因为操作系统可能面临内存不足的场景，此时操作系统就要立即刷新。

# 我们通过库函数接口，把数据拷贝到语言缓冲区，把语言缓冲刷新到内核缓冲区，内核缓冲区刷新到硬件等本质都是拷贝。所以计算机数据的流动本质：一切皆拷贝！

# 知道了缓冲区的刷新类型后，我们再对上面的代码进行分析：因为我们对文件进行了重定向，让本应该向屏幕打印的信息输入进一个磁盘文件，这时缓冲策略就从行缓冲变成了全缓冲，全缓冲需要程序结束之后才会向磁盘刷新文件内容，但是在此之前文件我们已经调用close接口关闭了对于的文件描述符，此时程序结束后就无法找到对应的文件，自然也不会对文件进行任何写入。所以一般为了解决这个问题，我们可以使用fflush函数提前刷新缓冲区。

4、系统级(内核)缓冲区

# 不仅是我们语言方面存在缓冲区，我们操作系统内部也会存在一个缓冲区，我们一般称为内核缓冲区。同样语言缓冲区刷新到系统缓冲区也遵循三种刷新策略。

# 所以说我们使用语言所提供的接口如printf对文件进行写入数据，首先会将数据存放在语言缓冲区，然后根据不同的刷新规则再刷新到系统缓冲区中，最后才会将系统缓冲区的数据刷新到磁盘或者对应的外设之中。

# 比如说我们看看下面这段代码：

int main()
{
	//库函数
	printf("hello printf\n");
	fprintf(stdout, "hello fprintf\n");
	const char *s = "hello fwrite\n";
	fwrite(s, strlen(s), 1, stdout);

	//系统调用
	const char *ss = "hello write\n";
	write(1, ss, strlen(ss));

	//???
	fork();

    return0;
}

# 为什么重定向之后的内容会与之前截然不同呢？

# 这是因为我们执行可执行程序，打印到屏幕，默认是行缓冲，所以直接打印所以数据。但是如果我们对数据进行重定向的话，向磁盘写入数据，默认为全缓冲，此时数据都会存在语言缓冲区中。而此时我们创建子进程，父子进程之间代码数据共享，进程结束之后对语言缓冲区进行刷新，本质就是对数据进行修改，为了进程之间的独立性，就会发生写实拷贝，所以重定向之后C语言接口的数据打印会答应两份。而因为系统接口write写入的数据是直接写入系统缓冲区的，不需要发生写实拷贝，所以只打印一份。

二、自定义glibc

# 现在我们可以自己封装出一个fopen等库函数。

1、头文件

定义宏表示文件打开方式权限位

定义IO_FILE结构体包含文件描述符文件打开方式

文件缓冲区字符数组缓冲区长度刷新方式

声明库函数

#pragma once

#include <stdio.h>

#define MAX 1024
#define NONE_FLUSH (1<<0)
#define LINE_FLUSH (1<<1)
#define FULL_FLUSH (1<<2)

typedef struct IO_FILE
{
    int fileno;
    int flag;
    char outbuffer[MAX];
    int bufferlen;
    int flush_method;
}MyFile;


MyFile *MyFopen(const char *path, const char *mode);
void MyFclose(MyFile *);
int MyFwrite(MyFile *, void *str, int len);
void MyFFlush(MyFile *);

2、BuyFile函数

申请IO_FILE结构体空间

初始化结构体内容 meset初始化缓冲区内容为0

返回结构体指针

static MyFile* BuyFile(int fd, int flag)
{
	MyFile* ret = (MyFile*)malloc(sizeof(MyFile));
	ret->fileno = fd;
	ret->flag = flag;
	ret->bufferlen = 0;
	ret->flush_method = LINE_FLUSH;
	memset(ret->outbuffer, 0, sizeof(ret->outbuffer));
	return ret;
}

3、MyFopen函数

定义文件描述符fd和打开方式

根据打开方式参数mode分流设置对应的打开方式

调用open系统调用打开path文件 BuyFile申请IO_FILE结构体

申请缓冲区返回BuyFile的指针

MyFile* MyFopen(const char* path, const char* mode)
{
	int fd = -1;
	int flag = 0;
	if (strcmp(mode, "w") == 0)
	{
		flag = O_CREAT | O_WRONLY | O_TRUNC;
		fd = open(path, flag, 0666);
	}
	else if (strcmp(mode, "a") == 0)
	{
		flag = O_CREAT | O_WRONLY | O_APPEND;
		fd = open(path, flag, 0666);
	}
	else if (strcmp(mode, "r") == 0)
	{
		flag = O_RDONLY;
		fd = open(path, flag);
	}
	else
	{

	}
	if (fd < 0)
	{
		return NULL;
	}
	return BuyFile(fd, flag);
}

4、MyFclose函数

判断文件描述符合法性调用MyFFlush刷新文件缓冲区

调用close关闭文件 free释放IO_FILE结构体

void MyFclose(MyFile* file)
{
	if (file->fileno 《》 0)
	{
		return;
	}
	MyFFlush(file);
	MyFclose(file);
	free(file);
}

5、MyFwrite函数

memcpy拷贝内容到缓冲区更新缓冲区长度

判断如果刷新方式为行刷新并且最后缓冲区最后一个字符为\n

调用MyFFlush刷新缓冲区

int MyFwrite(MyFile* file, void* str, int len)
{
	memcpy(file->outbuffer + file->bufferlen, str, len);
	file->bufferlen += len;
	printf("%d->\n", file->bufferlen);
	if ((file->flush_method & LINE_FLUSH) && file->outbuffer[file->bufferlen - 1] == '\n')
	{
		MyFFlush(file);
	}
	return 0;
}

6、MyFFlush函数

如果缓冲区为空不刷新

调用write刷新到文件缓冲区

文件缓冲区是否刷新到文件有操作系统决定

如果一定要刷新到文件中可以使用fsync强制刷新然后缓冲区长度为0；

void MyFFlush(MyFile* file)
{
	if (file->bufferlen <= 0)
	{
		return;
	}
	int n = write(file->fileno, file->outbuffer, file->bufferlen);
	//强制刷新
	fsync(file->fileno);
	file->bufferlen = 0;
}

7、测试一

所以这里我们不断向文件缓冲区写入不刷新此时缓冲区的内容越来越多当循环结束Flose后语言缓冲区的内容统一刷新到内核文件缓冲区

此时文件的内容突然增多了因为我们fsync强制刷新了否则刷新到内核文件缓冲区不一定刷新到文件！

int main()
{
	MyFile *filep = MyFopen("./log.txt", "a");
	if(!filep)
	{
		printf("fopen error!\n");
		return 1;
	}

	//char *msg = (char*)"hello myfile!\n";
	int cnt = 10;
	while(cnt--)
	{
		char *msg = (char*)"hello myfile!!!!!";
		MyFwrite(filep, msg, strlen(msg));
		printf("buffer:%s\n", filep->outbuffer);
		sleep(1);
	}
	

	MyFclose(filep);// FILE *fp
		
	return 0;

}

8、测试二

这里我们写一次刷新一次所以缓冲区的内容永远只有一条消息但是文件的内容写入一条增多一条消息。

int main()
{
	MyFile *filep = MyFopen("./log.txt", "a");
	if(!filep)
	{
		printf("fopen error!\n");
		return 1;
	}

	//char *msg = (char*)"hello myfile!\n";
	int cnt = 10;
	while(cnt--)
	{
		char *msg = (char*)"hello myfile!!!!!";
		MyFwrite(filep, msg, strlen(msg));
		MyFFlush(filep);
		printf("buffer:%s\n", filep->outbuffer);
		sleep(1);
	}
	

	MyFclose(filep);// FILE *fp
		
	return 0;

}