在Java中强制文件同步/刷新

你需要告诉我们更多关于硬件和操作系统,还有具体的Java版本。你是如何衡量这个吞吐量的?

正确的做法是,强制/同步应将数据强制输出到物理媒体。

这是原版的拷贝。在IntelMac上用GCC4.0编译应该是干净的。

/* rawcopy -- pure C, system calls only, copy argv[1] to argv[2] */

/* This is a test program which simply copies from file to file using
 * only system calls (section 2 of the manual.)
 *
 * Compile:
 *
 *      gcc -Wall -DBUFSIZ=1024 -o rawcopy rawcopy.c
 *
 * If DIRTY is defined, then errors are interpreted with perror(3).
 * This is ifdef'd so that the CLEAN version is free of stdio.  For
 * convenience I'm using BUFSIZ from stdio.h; to compile CLEAN just
 * use the value from your stdio.h in place of 1024 above.
 *
 * Compile DIRTY:
 *
 *      gcc -DDIRTY -Wall -o rawcopy rawcopy.c
 *
 */
#include <fcntl.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <stdlib.h>
#include <unistd.h>
#if defined(DIRTY)
#   if defined(BUFSIZ)
#       error "Don't define your own BUFSIZ when DIRTY"
#   endif
#   include <stdio.h>
#   define PERROR perror(argv[0])
#else
#   define CLEAN
#   define PERROR
#   if ! defined(BUFSIZ)
#       error "You must define your own BUFSIZ with -DBUFSIZ=<number>"
#   endif
#endif

char * buffer[BUFSIZ];          /* by definition stdio BUFSIZ should
                                   be optimal size for read/write */

extern int errno ;              /* I/O errors */

int main(int argc, char * argv[]) {
    int fdi, fdo ;              /* Input/output file descriptors */
    ssize_t len ;               /* length to read/write */
    if(argc != 3){
        PERROR;
        exit(errno);
    }

    /* Open the files, returning perror errno as the exit value if fails. */
    if((fdi = open(argv[1],O_RDONLY)) == -1){
        PERROR;
        exit(errno);
    }
    if((fdo = open(argv[2], O_WRONLY|O_CREAT)) == -1){
        PERROR;
        exit(errno);
    }

    /* copy BUFSIZ bytes (or total read on last block) fast as you
       can. */
    while((len = read(fdi, (void *) buffer, BUFSIZ)) > -1){
        if(len == -1){
            PERROR;
            exit(errno);
        }
        if(write(fdo, (void*)buffer, len) == -1){
            PERROR;
            exit(errno);
        }
    }
    /* close and fsync the files */
    if(fsync(fdo) ==-1){
        PERROR;
        exit(errno);
    }
    if(close(fdo) == -1){
        PERROR;
        exit(errno);
    }
    if(close(fdi) == -1){
        PERROR;
        exit(errno);
    }

    /* if it survived to here, all worked. */
    exit(0);
}

实际上,在C语言中你只想打电话 fsync() 在一个文件描述符上,不是 sync() (或“同步”命令),它向内核发送信号 flush 所有缓冲区到磁盘系统范围。

如果你 strace (此处是特定于Linux的)您应该能够观察到 fSyc() 或 fdatasync() 正在对输出文件进行系统调用。这就是我所期望的 getFD() . 同步() 打电话去做。我假设 c.force(true) 只需标记到NIO fSyc() 每次写入后都应调用。可能只是您使用的JVM实际上并没有实现 同步() 打电话?

我不知道为什么在将“sync”作为命令调用时看不到任何区别:但显然,在第一次同步调用之后,后续的调用通常要快得多。再说一次,我倾向于爆发 斯特雷斯 (truss on solaris)作为“这里到底发生了什么?”工具。

最好使用同步I/O数据完整性完成。但是,您的C样本使用的方法不正确。你用 sync() ,用于同步整个操作系统。

如果要将单个文件的块写入磁盘,则需要使用 fsync(2) 或 fdatasync(2) 在C. BTW中:当你在C中使用缓冲的STDIO(或者BuffReDeExtStudio流或爪哇的某个作者)时,在同步之前,首先需要刷新两者。

这个 fdatasync() 如果文件自同步后未更改名称或大小,则variant的效率会提高一点。但它也可能无法传递所有的元数据。如果您想编写自己的事务安全数据库系统,则需要观察更多的内容(如fsynching父目录)。

C代码可能是次优的,因为它使用stdio而不是raw os write()。但是,Java可以更优化,因为它分配更大的缓冲区?

不管怎样,你只能相信Apidoc。剩下的超出了你的职责范围。

(我知道这是一个非常晚的回复,但我在谷歌搜索时遇到了这个线索,这可能也是你在这里的结局。)

您在爪哇上的调用Syc()在单个文件描述符上,因此只有与该文件相关的缓冲区才被刷新到磁盘。

在C和命令行中,您在整个操作系统上调用sync(),所以每个文件缓冲区都会被清空到磁盘上,因为您的O/S正在做什么。

要进行比较,C调用应该是到syncfs(fp);

从Linux手册页:

   sync() causes all buffered modifications to file metadata and data to
   be written to the underlying file systems.

   syncfs() is like sync(), but synchronizes just the file system contain‐
   ing file referred to by the open file descriptor fd.