How Zero-Copy Supercharges Java Backend Performance

Zero‑Copy Overview

Zero‑copy means data does not need to be copied back and forth between user space and kernel space, dramatically improving system performance. The term appears frequently in Java NIO, Netty, Kafka, RocketMQ and similar frameworks as a key performance highlight.

I/O Concepts

1. Buffer

Buffers are the foundation of all I/O. An I/O operation moves data into or out of a buffer. When a process issues a read request, the kernel either copies data from its own buffer to the process buffer or, if the data is not in memory, reads it from disk into the kernel buffer via DMA before copying it to the process buffer. Write operations copy data from the user buffer to the kernel socket buffer and then to the network card, also using DMA.

Zero‑copy aims to eliminate these extra copies.

Two common zero‑copy methods are mmap+write and sendfile.

2. Virtual Memory

Modern operating systems use virtual memory, mapping virtual addresses to physical memory. This allows multiple virtual addresses to refer to the same physical page and lets the virtual address space be larger than physical memory. By mapping kernel and user space to the same physical page, DMA can fill a buffer visible to both, removing the need for a copy between kernel and user space.

3. mmap+write

Using mmap maps a file directly into a process’s address space, eliminating the kernel‑to‑user copy for reads. The kernel still copies data from the read buffer to the socket buffer, but the initial file‑to‑kernel copy is avoided.

4. sendfile

The sendfile system call, introduced in kernel 2.1, transfers data directly between a file descriptor and a socket descriptor inside the kernel, removing both user‑space copies and many context switches. Later kernels further reduced copies by storing buffer descriptors in the socket buffer.

Java Zero‑Copy

1. MappedByteBuffer

Java NIO’s FileChannel.map() creates a MappedByteBuffer, a virtual‑memory‑mapped buffer whose contents reside in a file on disk. get() reads data from the file, while put() writes back to the file, visible to other readers.

The method takes three parameters: MapMode (READ_ONLY, READ_WRITE, PRIVATE), position (start offset), and size (length).

PRIVATE mode implements copy‑on‑write: modifications are kept in a private copy that disappears when the buffer is garbage‑collected.

2. DirectByteBuffer

DirectByteBuffer

extends MappedByteBuffer and allocates memory outside the JVM heap, reducing GC pressure. It can also be allocated manually.

3. Channel‑to‑Channel Transfer

FileChannel.transferTo()

moves bytes directly from one channel to another without an intermediate buffer, further reducing copies and context switches.

Netty Zero‑Copy

Netty provides composite and slice buffers that combine multiple ByteBuffer instances into a single logical message without copying data. The CompositeChannelBuffer stores references to component buffers and their indices, enabling zero‑copy transmission.

Other Zero‑Copy Implementations

RocketMQ writes messages sequentially to a commit log and uses mmap+write for consumer reads. Kafka also employs sendfile to transfer persisted data to the network without extra copies.

Conclusion

Zero‑copy in Java works like using object references: all parts of the system operate on the same underlying data, eliminating redundant copies and improving performance.