多线程下的fwrite和write

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

1、实验描述：

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

2、代码如下：

#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

    printf("successs...");
    return 0;
}

3、实验结果：

1）定义了宏USE_CLIB，即使用C库的fwrite，其结果如下：

2）注释掉红USE_CLIB，使用文件IO的write，并且打开文件时不使用O_APPEND参数，其结果如下：

3）注释掉红USE_CLIB，使用文件IO的write，并且打开文件时使用O_APPEND，其结果如下：

4、实验结论：

无论是C库的fwrite还是文件IO的write都可以保证输出不会混杂——即多线程的输出不会混在一起出现aaabbb等情况。
使用C库的fwrite是线程安全的函数。
使用文件IO的write时，并且open文件时不使用O_APPEND参数，最终的文件行数是非预期的，远小于总数3百万行。也就证明了，write是非“线程安全”的。多线程下，其输出会互相覆盖。
使用文件IO的write时，并且open文件时使用O_APPEND参数，是线程安全的。

5、说明：

为什么结果是这样的？

1）我们先看fwrite的实现，下面的代码来自与glibc的截图:

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

2）write的实现，见下图：

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

最后总结：C库的fwrite是线程安全函数，而文件IO的write则需要额外的标志位O_APPEND做追加写，来保证偏移的不重叠，实现预期的并发写入。

多线程下的fwrite和write

Supongo que te gusta