Java NIO FileChannel实现大文件传输的性能优化指南

long position = 0;
long count = sourceChannel.size();
while (position < count) {
    long transferred = sourceChannel.transferTo(position, count - position, destChannel);
    position += transferred;
}

MappedByteBuffer buffer = sourceChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize);
byte[] dst = new byte[1024 * 1024];
while (buffer.hasRemaining()) {
    int len = Math.min(buffer.remaining(), dst.length);
    buffer.get(dst, 0, len);
    destStream.write(dst, 0, len);
}

AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open(
    Paths.get(sourcePath), StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocateDirect(4 * 1024 * 1024);
long position = 0;
CompletionHandler<Integer, Long> handler = new CompletionHandler<>() {
    @Override
    public void completed(Integer result, Long pos) {
        if (result > 0) {
            position = pos + result;
            asyncChannel.read(buffer, position, position, this);
        } else {
            // 传输完成
        }
    }
    @Override
    public void failed(Throwable exc, Long pos) {
        exc.printStackTrace();
    }
};
asyncChannel.read(buffer, position, position, handler);

public long transferTo(long position, long count, WritableByteChannel target) throws IOException {
    long transferred = 0;
    while (transferred < count) {
        long bytes = sendfile(this.fd, target.fd, position + transferred, count - transferred);
        if (bytes <= 0) break;
        transferred += bytes;
    }
    return transferred;
}

public class ZeroCopyFileCopy {
    public static void main(String[] args) throws IOException {
        Path src = Paths.get("/data/largefile.dat");
        Path dst = Paths.get("/data/largefile_copy.dat");
        try (FileChannel in = FileChannel.open(src, StandardOpenOption.READ);
             FileChannel out = FileChannel.open(dst, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            long size = in.size();
            long pos = 0;
            long start = System.currentTimeMillis();
            while (pos < size) {
                pos += in.transferTo(pos, size - pos, out);
            }
            System.out.println("Zero-copy take: " + (System.currentTimeMillis() - start) + " ms");
        }
    }
}

public class AsyncFileTransfer {
    private static final int PARTITION_SIZE = 64 * 1024 * 1024;
    public static void main(String[] args) throws Exception {
        AsynchronousFileChannel in = AsynchronousFileChannel.open(
            Paths.get("/data/huge.dat"), StandardOpenOption.READ);
        ExecutorService pool = Executors.newFixedThreadPool(4);

        long fileSize = in.size();
        List<Future<?>> futures = new ArrayList<>();
        for (long pos = 0; pos < fileSize; pos += PARTITION_SIZE) {
            long start = pos;
            long size = Math.min(PARTITION_SIZE, fileSize - start);
            futures.add(pool.submit(() -> {
                try {
                    ByteBuffer buffer = ByteBuffer.allocateDirect((int) size);
                    Future<Integer> readResult = in.read(buffer, start);
                    readResult.get(); // 等待读取完成
                    buffer.flip();
                    // 写入目标，比如网络通道或其他FileChannel
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }));
        }
        for (Future<?> f : futures) {
            f.get();
        }
        pool.shutdown();
    }
}