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

🕗 发布于 2024-09-22 16:41 linux 服务器 算法

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

验证一些现象

一个进程内多次 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);
}

原文地址：https://blog.csdn.net/qq_45398836/article/details/142413918

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：概率论原理精解【15】
下一篇：技术周总结 09.16~09.22 周日(架构 C# 数据库)

量化交易系统开发-实时行情自动化交易-3.4.3.3.期货市场深度数据
市场深度数据（Order Book Data）是了解市场供需力量的重要工具，显示了不同价位上买卖挂单的数量。通过分析市场深度数据，交易者可以识别支撑位和阻力位，了解流动性情况，为交易策略提供决策依据。
阅读更多2024-11-17
出现“ERR_CONNECTION_REFUSED”的原因及解决方法
通过尝试上述方法，您可能能够解决“ERR_CONNECTION_REFUSED”错误并成功访问该网站。如果问题仍然存在，可能需要进一步深入调查或与技术支持团队联系以解决问题。出现“ERR_CONNEC
阅读更多2024-11-17
聚类分析 | MSADBO优化Spectral谱聚类优化算法
聚类分析 | MSADBO优化Spectral谱聚类优化算法
阅读更多2024-11-17
应用层协议之WebSocket
WebSocket是一种强大的实时通信协议，它的双向通信和持久连接特性使得它在许多实时应用场景中发挥着重要作用。然而，在使用WebSocket时也需要注意其兼容性和安全性问题，并合理评估其对服务器资源
阅读更多2024-11-17
Python的秘密基地--Python基础知识
Python是一种高级、解释型、动态和多范式的编程语言，由Guido van Rossum于1989年底首次发布，1991年正式发布第一个版本。Python以简洁、易读和高效著称，非常适合初学者和专业
阅读更多2024-11-17
泛型11.16
①泛型是Java5的新特性，属于编译阶段的功能。②泛型可以让开发者在编写代码时指定集合中存储的数据类型③泛型作用：1.类型安全：指定了集合中元素的类型之后，编译器会在编译时进行类型检查，如果尝试将错误
阅读更多2024-11-17
Go语言24小时极速学习教程（三）常见标准库用法
常见标准库即Go语言自带的库，这里的所有包都可以通过import直接引入，如果你觉得实在是不好用，那么请先保证你学会了标准库的基础上，再学一下`Gookit`，特别是其中的`GoUtil`，千万不要轻
阅读更多2024-11-17
长连接配置以及断线重连
长连接配置以及断线重连
阅读更多2024-11-17
IDEA2024：右下角显示内存
实时知晓idea内存使用情况。
阅读更多2024-11-17
【Python】如何设置VSCode中的Pylint，消除各种没有必要的警告
最近打开VSCode，编辑之前创建的Python项目，突然发现多了一堆报错和警告，如下图所示。就非常吓人，因为之前这个项目是没有任何报错的，我赶紧试着运行了一下，还好，可以正常运行，那就说明是检测出了
阅读更多2024-11-17

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

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

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

相关文章