linux多线程下的fwrite和write使用详解

一时失言乱红尘 2022-12-27 08:34 255阅读 0赞

Linux下的文件操作，有人喜欢用C库的文件流操作，有人喜欢用Linux的原生的系统调用。一般来说，C库的文件操作会更高效一些，因为C库自己做了文件缓存的处理。今天，主要研究多线程下的fwrite与write，每个线程都对相同的FILE\*或者fd进行写操作，看看结果是否为预期行为。

第一种情况：使用C库的fwrite，其线程的实现如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]

第二种情况：使用系统调用write，其线程的实现如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]

下面看主线程的实现：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 2]

其中LOOPS定义为1000000。也就是说，线程1~3分别写入"aaaaaa\\n"，“bbbbbb\\n”，和"cccccc\\n"各一百万次。如果写入文件的操作是“线程安全”的，那么最终的文件行数应该是3百万行，且每行只可能是"aaaaaa"、“bbbbbb”、和"cccccc"的一种。

**【文章福利】需要C/C++ Linux服务器架构师学习资料加群812855908（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70]

接下来看测试结果：

1、定义了宏USE\_CLIB，即使用C库的fwrite，其结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 3]

2、注释掉红USE\_CLIB，即直接使用系统调用write，其结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 4]

从上面的测试结果看，无论是C库的fwrite还是系统调用的write都可以保证输出不会混杂——即多线程的输出不会混在一起，但是使用系统调用write时，最终的文件行数是非预期的，远小于总数3百万行。也就证明了，write系统调用是非“线程安全”的。多线程下，其输出会互相覆盖。而C库的fwrite是线程安全的函数。

为什么结果是这样的？我们先看fwrite的实现：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 5]

在fwrite内部，其使用一个lock保证操作的串行化，从而实现线程安全。

而write的实现，见下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 6]

在写入之前，使用file\_pos\_read拿到偏移。如果在多核多线程的情况下，两个核心可能同时陷入内核态，同时获得文件的当前偏移，其值必然是相等的。于是两个线程往同一个偏移写入了数据。最后导致文件的实际大小，并不是预期大小。

最后总结：  
C库的fwrite是线程安全函数，而系统调用write则需要额外的标志位O\_APPEND做追加写，来保证偏移的不重叠，实现预期的并发写入 —— 大家可以通过修改下面的测试代码，在自己的环境中测试。

#include <stdlib.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <pthread.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    
    //#define USE_CLIB
    
    #define TEST_FILE "./tmp.txt"
    
    #define LOOPS (1000000)
    
    
    #ifdef USE_CLIB
    struct thr_data { 
    	FILE *fp;
    	const char *data;
    };
    
    static void * write_data(void *data)
    { 
    	struct thr_data *d;
    	size_t len;
    	int i;
    
    	d = data;
    	len = strlen(d->data);
    	for (i = 0; i < LOOPS; ++i) { 
    		fwrite(d->data, len, 1, d->fp);
    	}
    
    	return NULL;
    }
    
    #else
    struct thr_data { 
    	int fd;
    	const char *data;
    };
    
    static void *write_data(void *data)
    { 
    	struct thr_data *d;
    	int i;
    	size_t len;
    
    	d = data;
    	len = strlen(d->data);
    	for (i = 0; i < LOOPS; ++i) { 
    		write(d->fd, d->data, len); 
    	}
    
    	return NULL;
    }
    #endif
    
    
    
    int main(void)
    { 
    	pthread_t t1, t2, t3;
    	struct thr_data d1, d2, d3;
    
    #ifdef USE_CLIB
    	FILE *fp = fopen(TEST_FILE, "w");
    	d1.fp = d2.fp = d3.fp = fp;
    #else
    	//int fd = open(TEST_FILE, O_WRONLY|O_TRUNC);
    	int fd = open(TEST_FILE, O_WRONLY|O_TRUNC|O_APPEND);
    	d1.fd = d2.fd = d3.fd = fd;
    #endif
    
    	d1.data = "aaaaaa\n";
    	d2.data = "bbbbbb\n";
    	d3.data = "cccccc\n";
    
    	pthread_create(&t1, NULL, write_data, &d1);
    	pthread_create(&t2, NULL, write_data, &d2);
    	pthread_create(&t3, NULL, write_data, &d3);
    
    	pthread_join(t1, NULL);
    	pthread_join(t2, NULL);
    	pthread_join(t3, NULL);
    
    #ifdef USE_CLIB
    	fclose(fp);
    #else
    	close(fd);
    #endif
    
    	return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/6c07b66f8eb24cd68b272f06a24f8a7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/d8e5f6d78b6d4edba403966d2faf4d6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/ad5cebec92774954a4a6993fc1ec936e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70]: /images/20221120/d4b382a6ee674ff5af28442e99ae6a4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/b12974e29f9c4fec9b4e70872d586df8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/1f8ba8038af94e179171312d6d314ed5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/374975caabb244a2862fc2b09d0a7375.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/29ec20c491b94496a9b338e78c18cbab.png