Mastering Zero-Copy in Java: Boost I/O Performance with NIO, Netty & Kafka

Introduction

Zero-copy means data does not need to be copied back and forth between user space and kernel space, greatly improving system performance. It is widely used in frameworks such as Java NIO, Netty, Kafka, and RocketMQ.

I/O Concepts

1. Buffer

A buffer is the basis of all I/O. When a process issues a read request, the kernel first checks if the required data is already in kernel space; if not, it reads from disk directly into the kernel read buffer via DMA, then copies to the user buffer. Write operations copy data from the user buffer to the kernel socket buffer and then to the NIC. Zero-copy aims to eliminate these copies, offering two approaches: mmap+write and sendfile.

2. Virtual Memory

Modern operating systems use virtual memory, allowing multiple virtual addresses to map to the same physical address. By mapping kernel and user space to the same physical memory, DMA can fill a buffer visible to both, avoiding copies.

Zero-Copy in Java

1. MappedByteBuffer

FileChannel.map() creates a memory‑mapped file, returning a MappedByteBuffer that accesses file data directly without an intermediate user‑space copy. Example code:

public class MappedByteBufferTest {
    public static void main(String[] args) throws Exception {
        File file = new File("D://db.txt");
        long len = file.length();
        MappedByteBuffer mappedByteBuffer = new FileInputStream(file)
            .getChannel().map(FileChannel.MapMode.READ_ONLY, 0, len);
        // read data...
    }
}

The map() method signature is:

public abstract MappedByteBuffer map(FileChannel.MapMode mode,
                                      long position, long size) throws IOException;

MapMode can be READ_ONLY, READ_WRITE, or PRIVATE. PRIVATE creates a copy‑on‑write buffer visible only to the MappedByteBuffer instance.

2. DirectByteBuffer

DirectByteBuffer extends MappedByteBuffer and allocates memory outside the JVM heap, avoiding garbage‑collector overhead. It can also be allocated manually:

ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(100);

3. Channel‑to‑Channel Transfer

FileChannel.transferTo() moves data directly between channels without an intermediate buffer:

public abstract long transferTo(long position, long count,
                                 WritableByteChannel target) throws IOException;

Example:

public class ChannelTransfer {
    public static void main(String[] args) throws Exception {
        String[] files = new String[1];
        files[0] = "D://db.txt";
        catFiles(Channels.newChannel(System.out), files);
    }
    private static void catFiles(WritableByteChannel target, String[] files) throws Exception {
        for (String f : files) {
            FileChannel channel = new FileInputStream(f).getChannel();
            channel.transferTo(0, channel.size(), target);
            channel.close();
        }
    }
}

Netty Zero‑Copy

Netty provides CompositeChannelBuffer and Slice to combine or split buffers without copying. The composite buffer holds references to component buffers, enabling zero‑copy data handling.

public class CompositeChannelBuffer extends AbstractChannelBuffer {
    private final ByteOrder order;
    private ChannelBuffer[] components;
    // ...
}

Other Zero‑Copy Uses

RocketMQ writes messages to a commit log using mmap+write, and Kafka uses sendfile for network transmission, both leveraging zero‑copy to reduce CPU and memory overhead.

Conclusion

Zero‑copy in Java essentially works with object references so that only a single copy of data exists, improving performance across I/O‑intensive applications.