Linux文件IO（六）-多次打开同一个文件

大家看到这个小节标题可能会有疑问，同一个文件还能被多次打开？事实确实如此，同一个文件可以被多次打开，譬如在一个进程中多次打开同一个文件、在多个不同的进程中打开同一个文件，那么这些操作都是被允许的。本小节就来探讨下多次打开同一个文件会有一些什么现象以及相应的细节问题？

验证一些现象

一个进程内多次 open 打开同一个文件，那么会得到多个不同的文件描述符 fd，同理在关闭文件的

时候也需要调用 close 依次关闭各个文件描述符。

针对这个问题，我们编写测试代码进行测试，如下所示：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
		 int fd1, fd2, fd3;
		 int ret;

		 /* 第一次打开文件 */
		 fd1 = open("./test_file", O_RDWR);
		 if (-1 == fd1) {
				 perror("open error");
				 exit(-1);
		 }

		 /* 第二次打开文件 */
		 fd2 = open("./test_file", O_RDWR);
		 if (-1 == fd2) {
				 perror("open error");
				 ret = -1;
				 goto err1;
		}

		 /* 第三次打开文件 */
		 fd3 = open("./test_file", O_RDWR);
		 if (-1 == fd3) {
				 perror("open error");
				 ret = -1;
				 goto err2;
		 }

		 /* 打印出 3 个文件描述符 */
		 printf("%d %d %d\n", fd1, fd2, fd3);
		 close(fd3);
		 ret = 0;
		err2:
		 close(fd2);

err1:
	 /* 关闭文件 */
	 close(fd1);
	 exit(ret);
}

上述示例代码中，通过 3 次调用 open 函数对 test_file 文件打开了 3 次，每一个调用传参一样，最后将3 次得到的文件描述符打印出来，在当前目录下存在 test_file 文件，接下来编译测试，看看结果如何：

从打印结果可知，三次调用 open 函数得到的文件描述符分别为 6、7、8，通过任何一个文件描述符对文件进行 IO 操作都是可以的，但是需要注意是，调用 open 函数打开文件使用的是什么权限，则返回的文件描述符就拥有什么权限，文件 IO 操作完成之后，在结束进程之前需要使用 close 关闭各个文件描述符。

在图中，细心的读者可能会发现，调用 open 函数得到的最小文件描述符是 6，在上一章节内容中给大家提到过，程序中分配得到的最小文件描述符一般是 3，但这里竟然是 6！这是为何？其实这个问题跟vscode 有关，说明 3、4、5 这 3 个文件描述符已经被 vscode 软件对应的进程所占用了，而当前这里执行testApp 文件是在 vscode 软件提供的终端下进行的，所以 vscode 可以认为是 testApp 进程的父进程，相反，testApp 进程便是 vscode 进程的子进程，子进程会继承父进程的文件描述符。关于子进程和父进程这些都是后面的内容，这里暂时不给大家进行介绍，这是只是给大家简单地解释一下，免得大家误会！其实可以直接在 Ubuntu 系统的 Terminal 终端执行 testApp，这时你会发现打印出来的文件描述符分别是 3、4、5，这里就不给大家演示了。

一个进程内多次 open 打开同一个文件，在内存中并不会存在多份动态文件。

当调用 open 函数的时候，会将文件数据（文件内容）从磁盘等块设备读取到内存中，将文件数据在内存中进行维护，内存中的这份文件数据我们就把它称为动态文件！这是前面给大家介绍的内容，这里再简单地提一下。这里出现了一个问题：如果同一个文件被多次打开，那么该文件所对应的动态文件是否在内存中也存在多份？也就是说，多次打开同一个文件是否会将其文件数据多次拷贝到内存中进行维护？

关于这个问题，各位读者可以简单地思考一下，这里我们直接编写代码进行测试，测试代码如下所示：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
		 char buffer[4];
		 int fd1, fd2;
		 int ret;

		 /* 创建新文件 test_file 并打开 */
		 fd1 = open("./test_file", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
		 if (-1 == fd1) {
				 perror("open error");
				 exit(-1);
		 }

		 /* 再次打开 test_file 文件 */
		 fd2 = open("./test_file", O_RDWR);
		 if (-1 == fd2) {
				 perror("open error");
				 ret = -1;
				 goto err1;
		 }

		 /* 通过 fd1 文件描述符写入 4 个字节数据 */
		 buffer[0] = 0x11;
		 buffer[1] = 0x22;
		 buffer[2] = 0x33;
		 buffer[3] = 0x44;
		 ret = write(fd1, buffer, 4);
		 if (-1 == ret) {
				 perror("write error");
				 goto err2;
		 }

		 /* 将读写位置偏移量移动到文件头 */
		 ret = lseek(fd2, 0, SEEK_SET);
		 if (-1 == ret) {
				 perror("lseek error");
				 goto err2;
		 }


		 /* 读取数据 */
		 memset(buffer, 0x00, sizeof(buffer));
		 ret = read(fd2, buffer, 4);
		 if (-1 == ret) {
				 perror("read error");
				 goto err2;
		 }
		 printf("0x%x 0x%x 0x%x 0x%x\n", buffer[0], buffer[1],
		 buffer[2], buffer[3]);
		 ret = 0;

	err2:
		 close(fd2);

	err1:
		 /* 关闭文件 */
		 close(fd1);
		 exit(ret);
}

当前目录下不存在 test_file 文件，上述代码中，第一次调用 open 函数新建并打开 test_file 文件，第二次调用 open 函数再次打开它，新建文件时，文件大小为 0；首先通过文件描述符 fd1 写入 4 个字节数据（0x11/0x22/0x33/0x44），从文件头开始写；然后再通过文件描述符 fd2 读取 4 个字节数据，也是从文件头开始读取。假如，内存中只有一份动态文件，那么读取得到的数据应该就是 0x11、0x22、0x33、0x44，如果存在多份动态文件，那么通过 fd2 读取的是与它对应的动态文件中的数据，那就不是 0x11、0x22、0x33、0x44，而是读取出 0 个字节数据，因为它的文件大小是 0。

接下来进行编译测试：

上图中打印显示读取出来的数据是 0x11/0x22/0x33/0x44，所以由此可知，即使多次打开同一个文件，内存中也只有一份动态文件。

一个进程内多次 open 打开同一个文件，不同文件描述符所对应的读写位置偏移量是相互独立的。同一个文件被多次打开，会得到多个不同的文件描述符，也就意味着会有多个不同的文件表，而文件读写偏移量信息就记录在文件表数据结构中，所以从这里可以推测不同的文件描述符所对应的读写偏移量是相互独立的，并没有关联在一起，并且文件表中 i-node 指针指向的都是同一个 inode，如下图所示：

测试的方法很简单，只需在示例代码中简单地修改即可，将 lseek 函数调用去掉，然后在编译测试，如果读出的数据依然是 0x11/0x22/0x33/0x44，则表示第三点结论成立，这里不再给大家演示。

Tips：多个不同的进程中调用 open()打开磁盘中的同一个文件，同样在内存中也只是维护了一份动态文件，多个进程间共享，它们有各自独立的文件读写位置偏移量。

动态文件何时被关闭呢？当文件的引用计数为 0 时，系统会自动将其关闭，同一个文件被打开多次，文件表中会记录该文件的引用计数，如图所示，引用计数记录了当前文件被多少个文件描述符 fd 关联。

多次打开同一文件进行读操作与 O_APPEND 标志

重复打开同一个文件，进行写操作，譬如一个进程中两次调用 open 函数打开同一个文件，分别得到两个文件描述符 fd1 和 fd2，使用这两个文件描述符对文件进行写入操作，那么它们是分别写（各从各的位置偏移量开始写）还是接续写（一个写完，另一个接着后面写）？因为这两个文件描述符所对应的读写位置偏移量是相互独立的，所以是分别写，接下来我们还是编写代码进行测试，测试代码如下所示：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
		 unsigned char buffer1[4], buffer2[4];
		 int fd1, fd2;
		 int ret;
		 int i;

		 /* 创建新文件 test_file 并打开 */
		 fd1 = open("./test_file", O_RDWR | O_CREAT | O_EXCL,
		 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
		 if (-1 == fd1) {
					 perror("open error");
					 exit(-1);
		 }

		 /* 再次打开 test_file 文件 */
		 fd2 = open("./test_file", O_RDWR);
		 if (-1 == fd2) {
				 perror("open error");
				 ret = -1;
				 goto err1;
		 }

		 /* buffer 数据初始化 */
		 buffer1[0] = 0x11;
		 buffer1[1] = 0x22;
		 buffer1[2] = 0x33;
		 buffer1[3] = 0x44;

		 buffer2[0] = 0xAA;
		 buffer2[1] = 0xBB;
		 buffer2[2] = 0xCC;
		 buffer2[3] = 0xDD;

		 /* 循环写入数据 */
		 for (i = 0; i < 4; i++) {
				 ret = write(fd1, buffer1, sizeof(buffer1));
				 if (-1 == ret) {
						 perror("write error");
						 goto err2;
				 }
		
				 ret = write(fd2, buffer2, sizeof(buffer2));
				 if (-1 == ret) {
						 perror("write error");
						 goto err2;
					 }
		 }

		 /* 将读写位置偏移量移动到文件头 */
		 ret = lseek(fd1, 0, SEEK_SET);
		 if (-1 == ret) {
				 perror("lseek error");
				 goto err2;
		 }

		 /* 读取数据 */
		 for (i = 0; i < 8; i++) {
				 ret = read(fd1, buffer1, sizeof(buffer1));
				 if (-1 == ret) {
						 perror("read error");
						 goto err2;
				 }

				 printf("%x%x%x%x", buffer1[0], buffer1[1],buffer1[2], buffer1[3]);
		 }
		 printf("\n");
		 ret = 0;
		
err2:
		 close(fd2);
		
err1:
		 /* 关闭文件 */
		 close(fd1);
		 exit(ret);
}

重复两次打开 test_file 文件，分别得到两个文件描述符 fd1、fd2；首先通过 fd1 写入 4 个字节数据（0x11、0x22、0x33、0x44）到文件中，接着再通过 fd2 写入 4 个字节数据（0xaa、0xbb、0xcc、0xdd）到文件中，循环写入 4 此；最后再将写入的数据读取出来，将其打印到终端。如果它们是分别写，那么读取出来的数据就应该是 aabbccdd……，因为通过 fd1 写入的数据被 fd2 写入的数据给覆盖了；如果它们是接续写，那么读取出来的数据应该是 11223344aabbccdd……，接下里我们编译测试：

从打印结果可知，它们确实是分别写。如果想要实现接续写，也就是当通过 fd1 写入完成之后，通过 fd2写入的数据是接在 fd1 写入的数据之后，那么该怎么做呢？当然可以写入数据之前通过 lseek 函数将文件偏移量移动到文件末尾，如果是这样做，会存在一些问题，关于这个问题后面再给大家介绍；这里我们给大家介绍使用 O_APPEND 标志来解决这个问题，也就是将分别写更改为接续写。

前面给大家介绍了 open 函数的 O_APPEND 标志，当 open 函数使用 O_APPEND 标志，在使用 write 函数进行写入操作时，会自动将偏移量移动到文件末尾，也就是每次写入都是从文件末尾开始；这里结合本小节的内容，我们再来讨论 O_APPEND 标志，在多次打开同一个文件进行写操作时，使用 O_APPEND 标志会有什么样的效果，接下来进行测试：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
		 unsigned char buffer1[4], buffer2[4];
		 int fd1, fd2;
		 int ret;
		 int i;

		 /* 创建新文件 test_file 并打开 */
		 fd1 = open("./test_file", O_RDWR | O_CREAT | O_EXCL | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
		 if (-1 == fd1) {
				 perror("open error");
				 exit(-1);
		 }

		 /* 再次打开 test_file 文件 */
		 fd2 = open("./test_file", O_RDWR | O_APPEND);
		 if (-1 == fd2) {
				 perror("open error");
				 ret = -1;
				 goto err1;
		 }

		 /* buffer 数据初始化 */
		 buffer1[0] = 0x11;
		 buffer1[1] = 0x22;
		 buffer1[2] = 0x33;
		 buffer1[3] = 0x44;

		 buffer2[0] = 0xAA;
		 buffer2[1] = 0xBB;
		 buffer2[2] = 0xCC;
		 buffer2[3] = 0xDD;

		 /* 循环写入数据 */
		 for (i = 0; i < 4; i++) {
				 ret = write(fd1, buffer1, sizeof(buffer1));
				 if (-1 == ret) {
						 perror("write error");
						 goto err2;
					}

				 ret = write(fd2, buffer2, sizeof(buffer2));
				 if (-1 == ret) {
						 perror("write error");
						 goto err2;
				 }
		 }

		 /* 将读写位置偏移量移动到文件头 */
		 ret = lseek(fd1, 0, SEEK_SET);
		 if (-1 == ret) {
				 perror("lseek error");
				 goto err2;
		 }

		 /* 读取数据 */
		 for (i = 0; i < 8; i++) {
				 ret = read(fd1, buffer1, sizeof(buffer1));
				 if (-1 == ret) {
						 perror("read error");
						 goto err2;
				 }

				 printf("%x%x%x%x", buffer1[0], buffer1[1],buffer1[2], buffer1[3]);
		 }
		 printf("\n");
		 ret = 0;
		
err2:
		 close(fd2);
		
err1:
		 /* 关闭文件 */
		 close(fd1);
		 exit(ret);
}