如果我将文件中的字节读入 byte[]，我发现当数组大约为 1 MB 时 FileInputStream 的性能比 128 KB 更差。在我测试过的 2 个工作站上，它的速度几乎是 128 KB 的两倍。这是为什么？

import java.io.*;

public class ReadFileInChuncks 
{
    public static void main(String[] args) throws IOException 
    {
        byte[] buffer1 = new byte[1024*128];
        byte[] buffer2 = new byte[1024*1024];

        String path = "some 1 gb big file";

        readFileInChuncks(path, buffer1, false);

        readFileInChuncks(path, buffer1, true);
        readFileInChuncks(path, buffer2, true);
        readFileInChuncks(path, buffer1, true);
        readFileInChuncks(path, buffer2, true);
    }

    public static void readFileInChuncks(String path, byte[] buffer, boolean report) throws IOException
    {
        long t = System.currentTimeMillis();

        InputStream is = new FileInputStream(path);
        while ((readToArray(is, buffer)) != 0) {}

        if (report)
            System.out.println((System.currentTimeMillis()-t) + " ms");
    }

    public static int readToArray(InputStream is, byte[] buffer) throws IOException
    {
        int index = 0;
        while (index != buffer.length)
        {
            int read = is.read(buffer, index, buffer.length - index);
            if (read == -1)
                break;
            index += read;
        }
        return index;
    }
}

输出

422 ms 
717 ms 
422 ms 
718 ms

请注意，这是对已发布问题的重新定义。另一个被不相关的讨论所污染。我会将另一个标记为删除。

编辑:重复，真的吗？我当然可以编写一些更好的代码来证明我的观点，但是 this不回答我的问题

Edit2:我在 5 KB 到 1000 KB 之间的每个缓冲区上运行了测试
Win7/JRE 1.8.0_25 和糟糕的性能开始于 precis 508 KB 和所有后续。抱歉，错误的图表军团，x 是缓冲区大小，y 是毫秒

最佳答案

TL;DR The performance drop is caused by memory allocation, not by file reading issues.

一个典型的基准测试问题:你对一件事进行基准测试，但实际上衡量的是另一件事。

首先，当我使用RandomAccessFile、FileChannel 和ByteBuffer.allocateDirect 重写示例代码时，阈值消失了。 128K 和 1M 缓冲区的文件读取性能变得大致相同。

与直接 ByteBuffer I/O 不同 FileInputStream.read 不能将数据直接加载到 Java 字节数组中。它需要先将数据放入一些 native 缓冲区，然后使用 JNI SetByteArrayRegion 函数将其复制到 Java。

所以我们要看FileInputStream.read的原生实现。归结为 io_util.c 中的以下代码:

    if (len == 0) {
        return 0;
    } else if (len > BUF_SIZE) {
        buf = malloc(len);
        if (buf == NULL) {
            JNU_ThrowOutOfMemoryError(env, NULL);
            return 0;
        }
    } else {
        buf = stackBuf;
    }

这里BUF_SIZE == 8192。如果缓冲区大于这个保留的堆栈区域，则通过malloc分配一个临时缓冲区。在 Windows 上，malloc 通常通过 HeapAlloc 实现WINAPI 调用。

接下来，我在没有文件 I/O 的情况下单独测量了 HeapAlloc + HeapFree 调用的性能。结果很有趣:

     128K:    5 μs
     256K:   10 μs
     384K:   15 μs
     512K:   20 μs
     640K:   25 μs
     768K:   29 μs
     896K:   33 μs
    1024K:  316 μs  <-- almost 10x leap
    1152K:  356 μs
    1280K:  399 μs
    1408K:  436 μs
    1536K:  474 μs
    1664K:  511 μs
    1792K:  553 μs
    1920K:  592 μs
    2048K:  628 μs

如您所见，操作系统内存分配的性能在 1MB 边界处发生了巨大变化。这可以通过用于小块和大块的不同分配算法来解释。

更新

HeapCreate 的文档证实了关于大于 1MB 的 block 的特定分配策略的想法(参见 dwMaximumSize 描述)。

Also, the largest memory block that can be allocated from the heap is slightly less than 512 KB for a 32-bit process and slightly less than 1,024 KB for a 64-bit process.

...

Requests to allocate memory blocks larger than the limit for a fixed-size heap do not automatically fail; instead, the system calls the VirtualAlloc function to obtain the memory that is needed for large blocks.

关于java - 为什么 FileInputStream 读取的数组越大越慢，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28704067/