google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Zero-Copy Data Transfer in Java
awiskar acharya
November 13, 2025
12:03 pm

Introduction to Zero-Copy

Zero-copy is a technique that eliminates unnecessary data copying between memory spaces, significantly improving performance in I/O-intensive applications. Java provides several mechanisms for zero-copy data transfer, particularly for file and network operations.

Table of Contents

  1. Traditional vs Zero-Copy File Transfer
  2. FileChannel Transfer Methods
  3. Memory-Mapped Files
  4. Direct Buffers
  5. Network Zero-Copy
  6. NIO.2 Zero-Copy Operations
  7. Performance Benchmarks
  8. Best Practices

Traditional vs Zero-Copy File Transfer

Traditional File Copy

import java.io.*; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.file.*; public class TraditionalFileCopy { // Traditional stream-based copy (multiple copies) public static void traditionalStreamCopy(Path source, Path target) throws IOException { long startTime = System.nanoTime(); try (InputStream in = Files.newInputStream(source); OutputStream out = Files.newOutputStream(target)) { byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); } } long endTime = System.nanoTime(); System.out.printf("Traditional stream copy: %d ms%n", (endTime - startTime) / 1_000_000); } // Buffered stream copy (slightly better) public static void bufferedStreamCopy(Path source, Path target) throws IOException { long startTime = System.nanoTime(); try (BufferedInputStream in = new BufferedInputStream(Files.newInputStream(source)); BufferedOutputStream out = new BufferedOutputStream(Files.newOutputStream(target))) { byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); } } long endTime = System.nanoTime(); System.out.printf("Buffered stream copy: %d ms%n", (endTime - startTime) / 1_000_000); } // NIO channel copy with heap buffers (still copies) public static void nioChannelCopy(Path source, Path target) throws IOException { long startTime = System.nanoTime(); try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(8192); while (sourceChannel.read(buffer) != -1) { buffer.flip(); targetChannel.write(buffer); buffer.clear(); } } long endTime = System.nanoTime(); System.out.printf("NIO channel copy: %d ms%n", (endTime - startTime) / 1_000_000); } public static void main(String[] args) throws IOException { // Create test files Path source = Paths.get("test_source.dat"); Path target1 = Paths.get("test_target1.dat"); Path target2 = Paths.get("test_target2.dat"); Path target3 = Paths.get("test_target3.dat"); // Create a 100MB test file createTestFile(source, 100 * 1024 * 1024); // Test different copy methods traditionalStreamCopy(source, target1); bufferedStreamCopy(source, target2); nioChannelCopy(source, target3); // Cleanup Files.deleteIfExists(source); Files.deleteIfExists(target1); Files.deleteIfExists(target2); Files.deleteIfExists(target3); } private static void createTestFile(Path path, long size) throws IOException { try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(8192); long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); channel.write(buffer); bytesWritten += bytesToWrite; } } } }

FileChannel Transfer Methods

Zero-Copy File Transfer

import java.io.*; import java.nio.channels.FileChannel; import java.nio.file.*; public class ZeroCopyFileTransfer { // Using transferTo() for zero-copy file transfer public static void transferToCopy(Path source, Path target) throws IOException { long startTime = System.nanoTime(); try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long position = 0; long count = sourceChannel.size(); // Single transferTo call for entire file long transferred = sourceChannel.transferTo(position, count, targetChannel); System.out.printf("Transferred: %d bytes%n", transferred); } long endTime = System.nanoTime(); System.out.printf("transferTo zero-copy: %d ms%n", (endTime - startTime) / 1_000_000); } // Using transferFrom() for zero-copy file transfer public static void transferFromCopy(Path source, Path target) throws IOException { long startTime = System.nanoTime(); try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long position = 0; long count = sourceChannel.size(); // Single transferFrom call for entire file long transferred = targetChannel.transferFrom(sourceChannel, position, count); System.out.printf("Transferred: %d bytes%n", transferred); } long endTime = System.nanoTime(); System.out.printf("transferFrom zero-copy: %d ms%n", (endTime - startTime) / 1_000_000); } // Chunked transfer for very large files public static void chunkedTransferTo(Path source, Path target, long chunkSize) throws IOException { long startTime = System.nanoTime(); try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long fileSize = sourceChannel.size(); long position = 0; while (position < fileSize) { long remaining = fileSize - position; long bytesToTransfer = Math.min(chunkSize, remaining); long transferred = sourceChannel.transferTo(position, bytesToTransfer, targetChannel); position += transferred; System.out.printf("Transferred chunk: %d bytes, total: %d/%d%n", transferred, position, fileSize); } } long endTime = System.nanoTime(); System.out.printf("Chunked transferTo: %d ms%n", (endTime - startTime) / 1_000_000); } // Progress monitoring wrapper public static void transferWithProgress(Path source, Path target, ProgressListener listener) throws IOException { long fileSize = Files.size(source); try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long position = 0; long chunkSize = 64 * 1024 * 1024; // 64MB chunks while (position < fileSize) { long remaining = fileSize - position; long bytesToTransfer = Math.min(chunkSize, remaining); long transferred = sourceChannel.transferTo(position, bytesToTransfer, targetChannel); position += transferred; if (listener != null) { int progress = (int) ((position * 100) / fileSize); listener.onProgress(progress, position, fileSize); } // Small delay to see progress (remove in production) try { Thread.sleep(10); } catch (InterruptedException e) { break; } } } } @FunctionalInterface public interface ProgressListener { void onProgress(int percent, long bytesTransferred, long totalBytes); } public static void main(String[] args) throws IOException { Path source = Paths.get("large_source.dat"); Path target1 = Paths.get("target1.dat"); Path target2 = Paths.get("target2.dat"); Path target3 = Paths.get("target3.dat"); // Create a 500MB test file createLargeTestFile(source, 500 * 1024 * 1024); System.out.println("=== Zero-Copy File Transfer Benchmarks ==="); transferToCopy(source, target1); transferFromCopy(source, target2); System.out.println("\n=== Chunked Transfer ==="); chunkedTransferTo(source, target3, 128 * 1024 * 1024); // 128MB chunks System.out.println("\n=== Transfer with Progress ==="); transferWithProgress(source, Paths.get("target4.dat"), (percent, bytes, total) -> { System.out.printf("Progress: %d%% (%d/%d bytes)%n", percent, bytes, total); }); // Cleanup Files.deleteIfExists(source); Files.deleteIfExists(target1); Files.deleteIfExists(target2); Files.deleteIfExists(target3); Files.deleteIfExists(Paths.get("target4.dat")); } private static void createLargeTestFile(Path path, long size) throws IOException { System.out.printf("Creating test file of size: %d MB%n", size / (1024 * 1024)); try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); // 64KB buffer long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); // Fill with pattern for verification for (int i = 0; i < bytesToWrite; i++) { buffer.put((byte) (i % 256)); } buffer.flip(); channel.write(buffer); bytesWritten += bytesToWrite; if (bytesWritten % (10 * 1024 * 1024) == 0) { System.out.printf("Created: %d MB%n", bytesWritten / (1024 * 1024)); } } } System.out.println("Test file created successfully"); } }

Memory-Mapped Files

Memory-Mapped File Operations

import java.io.*; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel; import java.nio.file.*; import java.util.Random; public class MemoryMappedFiles { // Basic memory-mapped file read public static void memoryMappedRead(Path filePath) throws IOException { long startTime = System.nanoTime(); try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ)) { long fileSize = channel.size(); MappedByteBuffer buffer = channel.map( FileChannel.MapMode.READ_ONLY, 0, fileSize); // Read from memory-mapped buffer byte[] data = new byte[(int) fileSize]; buffer.get(data); // Verify first and last bytes System.out.printf("First byte: %d, Last byte: %d%n", data[0] & 0xFF, data[data.length - 1] & 0xFF); } long endTime = System.nanoTime(); System.out.printf("Memory-mapped read: %d ms%n", (endTime - startTime) / 1_000_000); } // Memory-mapped file write public static void memoryMappedWrite(Path filePath, long size) throws IOException { long startTime = System.nanoTime(); try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { MappedByteBuffer buffer = channel.map( FileChannel.MapMode.READ_WRITE, 0, size); // Write data directly to memory-mapped buffer Random random = new Random(); for (long i = 0; i < size; i++) { buffer.put((byte) random.nextInt(256)); } // Force changes to disk buffer.force(); } long endTime = System.nanoTime(); System.out.printf("Memory-mapped write: %d ms%n", (endTime - startTime) / 1_000_000); } // Large file processing with memory mapping public static void processLargeFile(Path inputPath, Path outputPath) throws IOException { long fileSize = Files.size(inputPath); long chunkSize = 256 * 1024 * 1024; // 256MB chunks try (FileChannel inputChannel = FileChannel.open(inputPath, StandardOpenOption.READ); FileChannel outputChannel = FileChannel.open(outputPath, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long position = 0; while (position < fileSize) { long remaining = fileSize - position; long mapSize = Math.min(chunkSize, remaining); // Map input chunk MappedByteBuffer inputBuffer = inputChannel.map( FileChannel.MapMode.READ_ONLY, position, mapSize); // Map output chunk MappedByteBuffer outputBuffer = outputChannel.map( FileChannel.MapMode.READ_WRITE, position, mapSize); // Process data (example: convert to uppercase for text, but we'll XOR for binary) processChunk(inputBuffer, outputBuffer); // Force output to disk outputBuffer.force(); position += mapSize; System.out.printf("Processed chunk: %d/%d bytes%n", position, fileSize); } } } private static void processChunk(MappedByteBuffer input, MappedByteBuffer output) { // Example processing: simple XOR transformation while (input.hasRemaining()) { byte b = input.get(); output.put((byte) (b ^ 0x55)); // Simple transformation } } // Shared memory between processes (conceptual) public static class SharedMemoryProcessor { private final Path sharedFile; private MappedByteBuffer buffer; private FileChannel channel; public SharedMemoryProcessor(Path sharedFile, long size) throws IOException { this.sharedFile = sharedFile; this.channel = FileChannel.open(sharedFile, StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE); this.buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, size); } public void writeData(byte[] data, int offset) { buffer.position(offset); buffer.put(data); buffer.force(); // Ensure data is written to disk } public byte[] readData(int offset, int length) { buffer.position(offset); byte[] data = new byte[length]; buffer.get(data); return data; } public void close() throws IOException { if (channel != null && channel.isOpen()) { channel.close(); } } } // Memory-mapped file search public static long searchInMappedFile(Path filePath, byte[] pattern) throws IOException { try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ)) { long fileSize = channel.size(); MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize); for (long i = 0; i <= fileSize - pattern.length; i++) { boolean found = true; for (int j = 0; j < pattern.length; j++) { if (buffer.get((int) (i + j)) != pattern[j]) { found = false; break; } } if (found) { return i; } } } return -1; // Not found } public static void main(String[] args) throws IOException { Path testFile = Paths.get("test_mmap.dat"); Path outputFile = Paths.get("output_mmap.dat"); System.out.println("=== Memory-Mapped File Operations ==="); // Create test file memoryMappedWrite(testFile, 100 * 1024 * 1024); // 100MB // Read test file memoryMappedRead(testFile); // Process file System.out.println("\n=== Processing Large File ==="); processLargeFile(testFile, outputFile); // Search in file System.out.println("\n=== Searching in File ==="); byte[] pattern = {0x55, 0x55, 0x55, 0x55}; long position = searchInMappedFile(testFile, pattern); System.out.printf("Pattern found at position: %d%n", position); // Test shared memory System.out.println("\n=== Shared Memory Test ==="); Path sharedFile = Paths.get("shared_memory.dat"); try (SharedMemoryProcessor smp = new SharedMemoryProcessor(sharedFile, 1024)) { byte[] testData = "Hello, Shared Memory!".getBytes(); smp.writeData(testData, 0); byte[] readData = smp.readData(0, testData.length); System.out.println("Read from shared memory: " + new String(readData)); } // Cleanup Files.deleteIfExists(testFile); Files.deleteIfExists(outputFile); Files.deleteIfExists(sharedFile); } }

Direct Buffers

Direct ByteBuffer Operations

import java.io.*; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.file.*; import java.lang.reflect.Method; public class DirectBuffers { // Compare heap buffer vs direct buffer performance public static void benchmarkBuffers(Path filePath, int bufferSize) throws IOException { long fileSize = Files.size(filePath); // Heap buffer benchmark long heapStart = System.nanoTime(); try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ)) { ByteBuffer heapBuffer = ByteBuffer.allocate(bufferSize); long totalRead = 0; while (totalRead < fileSize) { heapBuffer.clear(); int bytesRead = channel.read(heapBuffer); if (bytesRead == -1) break; totalRead += bytesRead; // Process buffer (simulate work) processBuffer(heapBuffer, bytesRead); } } long heapTime = System.nanoTime() - heapStart; // Direct buffer benchmark long directStart = System.nanoTime(); try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.READ)) { ByteBuffer directBuffer = ByteBuffer.allocateDirect(bufferSize); long totalRead = 0; while (totalRead < fileSize) { directBuffer.clear(); int bytesRead = channel.read(directBuffer); if (bytesRead == -1) break; totalRead += bytesRead; // Process buffer (simulate work) processBuffer(directBuffer, bytesRead); } } long directTime = System.nanoTime() - directStart; System.out.printf("Buffer size: %d KB%n", bufferSize / 1024); System.out.printf("Heap buffer time: %d ms%n", heapTime / 1_000_000); System.out.printf("Direct buffer time: %d ms%n", directTime / 1_000_000); System.out.printf("Direct buffer improvement: %.2fx%n", (double) heapTime / directTime); } private static void processBuffer(ByteBuffer buffer, int bytesRead) { // Simulate some processing buffer.flip(); for (int i = 0; i < bytesRead; i++) { byte b = buffer.get(); // Simple processing if (i % 1000 == 0) { // Do nothing, just simulate work } } } // Direct buffer pool for reuse public static class DirectBufferPool { private final ByteBuffer[] pool; private final boolean[] inUse; private final int bufferSize; public DirectBufferPool(int poolSize, int bufferSize) { this.pool = new ByteBuffer[poolSize]; this.inUse = new boolean[poolSize]; this.bufferSize = bufferSize; for (int i = 0; i < poolSize; i++) { pool[i] = ByteBuffer.allocateDirect(bufferSize); } } public ByteBuffer acquire() { synchronized (pool) { for (int i = 0; i < pool.length; i++) { if (!inUse[i]) { inUse[i] = true; pool[i].clear(); return pool[i]; } } } // Pool exhausted, create new buffer return ByteBuffer.allocateDirect(bufferSize); } public void release(ByteBuffer buffer) { synchronized (pool) { for (int i = 0; i < pool.length; i++) { if (pool[i] == buffer) { inUse[i] = false; return; } } } // Buffer not from pool, let GC handle it } public void cleanup() { synchronized (pool) { for (ByteBuffer buffer : pool) { cleanDirectBuffer(buffer); } } } private void cleanDirectBuffer(ByteBuffer buffer) { if (buffer.isDirect()) { cleaner = ((DirectBuffer) buffer).cleaner(); if (cleaner != null) { cleaner.clean(); } } } catch (Exception e) { // Ignore, JVM will handle cleanup } } } // Efficient file copy using direct buffer pool public static void efficientFileCopy(Path source, Path target, DirectBufferPool pool) throws IOException { try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long fileSize = sourceChannel.size(); long bytesCopied = 0; while (bytesCopied < fileSize) { ByteBuffer buffer = pool.acquire(); try { int bytesRead = sourceChannel.read(buffer); if (bytesRead == -1) break; buffer.flip(); while (buffer.hasRemaining()) { targetChannel.write(buffer); } bytesCopied += bytesRead; } finally { pool.release(buffer); } } } } // Direct buffer for network operations public static class NetworkBuffer { private final ByteBuffer buffer; private final int capacity; public NetworkBuffer(int capacity) { this.capacity = capacity; this.buffer = ByteBuffer.allocateDirect(capacity); } public void prepareForWrite() { buffer.clear(); } public void prepareForRead() { buffer.flip(); } public ByteBuffer getBuffer() { return buffer; } public int writeData(byte[] data, int offset, int length) { int bytesToWrite = Math.min(length, buffer.remaining()); buffer.put(data, offset, bytesToWrite); return bytesToWrite; } public int readData(byte[] data, int offset, int length) { int bytesToRead = Math.min(length, buffer.remaining()); buffer.get(data, offset, bytesToRead); return bytesToRead; } public boolean hasRemaining() { return buffer.hasRemaining(); } public int remaining() { return buffer.remaining(); } } public static void main(String[] args) throws IOException { Path testFile = Paths.get("benchmark_file.dat"); createTestFile(testFile, 200 * 1024 * 1024); // 200MB System.out.println("=== Direct Buffer Benchmark ==="); // Test different buffer sizes int[] bufferSizes = {4 * 1024, 16 * 1024, 64 * 1024, 256 * 1024, 1024 * 1024}; for (int size : bufferSizes) { benchmarkBuffers(testFile, size); System.out.println(); } // Test buffer pool System.out.println("=== Buffer Pool Test ==="); DirectBufferPool pool = new DirectBufferPool(10, 64 * 1024); Path targetFile = Paths.get("copy_target.dat"); efficientFileCopy(testFile, targetFile, pool); System.out.println("File copied using buffer pool"); // Cleanup pool.cleanup(); Files.deleteIfExists(testFile); Files.deleteIfExists(targetFile); } private static void createTestFile(Path path, long size) throws IOException { try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); // Fill with test data for (int i = 0; i < bytesToWrite; i++) { buffer.put((byte) (i % 256)); } buffer.flip(); channel.write(buffer); bytesWritten += bytesToWrite; } } } }

Network Zero-Copy

Zero-Copy Network Transfers

import java.io.*; import java.net.*; import java.nio.*; import java.nio.channels.*; import java.nio.file.*; import java.util.concurrent.*; public class NetworkZeroCopy { // File server using zero-copy file transfer public static class ZeroCopyFileServer { private final int port; private final Path fileDirectory; private volatile boolean running; public ZeroCopyFileServer(int port, Path fileDirectory) { this.port = port; this.fileDirectory = fileDirectory; } public void start() throws IOException { running = true; try (ServerSocketChannel serverChannel = ServerSocketChannel.open()) { serverChannel.bind(new InetSocketAddress(port)); serverChannel.configureBlocking(true); System.out.printf("Zero-copy file server started on port %d%n", port); ExecutorService executor = Executors.newFixedThreadPool(10); while (running) { SocketChannel clientChannel = serverChannel.accept(); executor.submit(() -> handleClient(clientChannel)); } executor.shutdown(); } } public void stop() { running = false; } private void handleClient(SocketChannel clientChannel) { try { // Simple protocol: first 4 bytes = filename length, then filename, then send file ByteBuffer headerBuffer = ByteBuffer.allocate(4); // Read filename length while (headerBuffer.hasRemaining()) { if (clientChannel.read(headerBuffer) == -1) { return; } } headerBuffer.flip(); int filenameLength = headerBuffer.getInt(); // Read filename ByteBuffer filenameBuffer = ByteBuffer.allocate(filenameLength); while (filenameBuffer.hasRemaining()) { if (clientChannel.read(filenameBuffer) == -1) { return; } } filenameBuffer.flip(); String filename = StandardCharsets.UTF_8.decode(filenameBuffer).toString(); Path filePath = fileDirectory.resolve(filename); if (!Files.exists(filePath)) { // Send error response ByteBuffer errorBuffer = ByteBuffer.allocate(4); errorBuffer.putInt(-1); errorBuffer.flip(); clientChannel.write(errorBuffer); return; } // Send file using zero-copy sendFile(clientChannel, filePath); } catch (IOException e) { System.err.println("Error handling client: " + e.getMessage()); } finally { try { clientChannel.close(); } catch (IOException e) { // Ignore } } } private void sendFile(SocketChannel clientChannel, Path filePath) throws IOException { try (FileChannel fileChannel = FileChannel.open(filePath, StandardOpenOption.READ)) { long fileSize = Files.size(filePath); // Send file size first ByteBuffer sizeBuffer = ByteBuffer.allocate(8); sizeBuffer.putLong(fileSize); sizeBuffer.flip(); clientChannel.write(sizeBuffer); // Zero-copy file transfer long position = 0; long transferred; do { transferred = fileChannel.transferTo(position, fileSize - position, clientChannel); if (transferred > 0) { position += transferred; } } while (position < fileSize); System.out.printf("Sent file: %s (%d bytes)%n", filePath.getFileName(), fileSize); } } } // Zero-copy file client public static class ZeroCopyFileClient { private final String host; private final int port; public ZeroCopyFileClient(String host, int port) { this.host = host; this.port = port; } public void downloadFile(String filename, Path localPath) throws IOException { try (SocketChannel serverChannel = SocketChannel.open( new InetSocketAddress(host, port))) { // Send filename byte[] filenameBytes = filename.getBytes(StandardCharsets.UTF_8); ByteBuffer headerBuffer = ByteBuffer.allocate(4 + filenameBytes.length); headerBuffer.putInt(filenameBytes.length); headerBuffer.put(filenameBytes); headerBuffer.flip(); serverChannel.write(headerBuffer); // Read file size ByteBuffer sizeBuffer = ByteBuffer.allocate(8); while (sizeBuffer.hasRemaining()) { if (serverChannel.read(sizeBuffer) == -1) { throw new IOException("Server closed connection"); } } sizeBuffer.flip(); long fileSize = sizeBuffer.getLong(); if (fileSize == -1) { throw new FileNotFoundException("File not found on server: " + filename); } // Receive file using zero-copy receiveFile(serverChannel, localPath, fileSize); System.out.printf("Downloaded file: %s (%d bytes)%n", filename, fileSize); } } private void receiveFile(SocketChannel serverChannel, Path localPath, long fileSize) throws IOException { try (FileChannel fileChannel = FileChannel.open(localPath, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long position = 0; long transferred; do { transferred = fileChannel.transferFrom(serverChannel, position, fileSize - position); if (transferred > 0) { position += transferred; } } while (position < fileSize); } } } // Non-blocking zero-copy server public static class NonBlockingZeroCopyServer { private final int port; private volatile boolean running; public NonBlockingZeroCopyServer(int port) { this.port = port; } public void start() throws IOException { running = true; try (Selector selector = Selector.open(); ServerSocketChannel serverChannel = ServerSocketChannel.open()) { serverChannel.configureBlocking(false); serverChannel.bind(new InetSocketAddress(port)); serverChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.printf("Non-blocking zero-copy server started on port %d%n", port); while (running) { if (selector.select(1000) == 0) { continue; } for (SelectionKey key : selector.selectedKeys()) { if (key.isAcceptable()) { acceptConnection(selector, (ServerSocketChannel) key.channel()); } else if (key.isReadable()) { handleRead(key); } else if (key.isWritable()) { handleWrite(key); } } selector.selectedKeys().clear(); } } } private void acceptConnection(Selector selector, ServerSocketChannel serverChannel) throws IOException { SocketChannel clientChannel = serverChannel.accept(); clientChannel.configureBlocking(false); clientChannel.register(selector, SelectionKey.OP_READ, new ClientSession()); System.out.println("Accepted connection from: " + clientChannel.getRemoteAddress()); } private void handleRead(SelectionKey key) throws IOException { SocketChannel channel = (SocketChannel) key.channel(); ClientSession session = (ClientSession) key.attachment(); // Handle protocol and file transfer setup // Implementation depends on specific protocol } private void handleWrite(SelectionKey key) throws IOException { SocketChannel channel = (SocketChannel) key.channel(); ClientSession session = (ClientSession) key.attachment(); // Handle file transfer using zero-copy // Implementation depends on specific protocol } public void stop() { running = false; } private static class ClientSession { // Session state for each client connection private String requestedFile; private long filePosition; private FileChannel fileChannel; // ... other session state } } public static void main(String[] args) throws Exception { // Create test directory and file Path testDir = Paths.get("test_server_files"); Files.createDirectories(testDir); Path testFile = testDir.resolve("large_file.dat"); createTestFile(testFile, 50 * 1024 * 1024); // 50MB test file // Start server in background thread ZeroCopyFileServer server = new ZeroCopyFileServer(8080, testDir); Thread serverThread = new Thread(() -> { try { server.start(); } catch (IOException e) { e.printStackTrace(); } }); serverThread.start(); // Give server time to start Thread.sleep(1000); // Test client ZeroCopyFileClient client = new ZeroCopyFileClient("localhost", 8080); Path downloadPath = Paths.get("downloaded_file.dat"); client.downloadFile("large_file.dat", downloadPath); // Verify file long originalSize = Files.size(testFile); long downloadedSize = Files.size(downloadPath); System.out.printf("Original size: %d, Downloaded size: %d%n", originalSize, downloadedSize); // Cleanup server.stop(); serverThread.join(1000); Files.deleteIfExists(testFile); Files.deleteIfExists(downloadPath); Files.deleteIfExists(testDir); } private static void createTestFile(Path path, long size) throws IOException { try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); for (int i = 0; i < bytesToWrite; i++) { buffer.put((byte) (i % 256)); } buffer.flip(); channel.write(buffer); bytesWritten += bytesToWrite; } } } }

NIO.2 Zero-Copy Operations

Files.copy and Other Zero-Copy Methods

import java.io.*; import java.nio.file.*; import java.nio.file.attribute.*; import java.util.*; public class NIO2ZeroCopy { // Using Files.copy for zero-copy file operations public static void filesCopyZeroCopy(Path source, Path target) throws IOException { long startTime = System.nanoTime(); // Files.copy may use zero-copy internally for same filesystem Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING); long endTime = System.nanoTime(); System.out.printf("Files.copy operation: %d ms%n", (endTime - startTime) / 1_000_000); } // Copy with attributes preservation public static void copyWithAttributes(Path source, Path target) throws IOException { long startTime = System.nanoTime(); CopyOption[] options = { StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES, LinkOption.NOFOLLOW_LINKS }; Files.copy(source, target, options); long endTime = System.nanoTime(); System.out.printf("Files.copy with attributes: %d ms%n", (endTime - startTime) / 1_000_000); } // Directory tree copy with zero-copy where possible public static void copyDirectoryTree(Path sourceDir, Path targetDir) throws IOException { Files.walkFileTree(sourceDir, new SimpleFileVisitor<Path>() { @Override public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { Path targetPath = targetDir.resolve(sourceDir.relativize(dir)); Files.createDirectories(targetPath); return FileVisitResult.CONTINUE; } @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { Path targetFile = targetDir.resolve(sourceDir.relativize(file)); // Use zero-copy for regular files Files.copy(file, targetFile, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES); return FileVisitResult.CONTINUE; } }); } // File move/rename (often zero-copy within same filesystem) public static void atomicMove(Path source, Path target) throws IOException { long startTime = System.nanoTime(); try { Files.move(source, target, StandardCopyOption.ATOMIC_MOVE); System.out.println("Atomic move successful"); } catch (AtomicMoveNotSupportedException e) { // Fall back to regular move Files.move(source, target, StandardCopyOption.REPLACE_EXISTING); System.out.println("Regular move (atomic not supported)"); } long endTime = System.nanoTime(); System.out.printf("File move operation: %d ms%n", (endTime - startTime) / 1_000_000); } // Bulk file operations public static class BulkFileProcessor { private final Path sourceDir; private final Path targetDir; public BulkFileProcessor(Path sourceDir, Path targetDir) { this.sourceDir = sourceDir; this.targetDir = targetDir; } public void processFiles() throws IOException { List<Path> files = Files.walk(sourceDir) .filter(Files::isRegularFile) .toList(); // Process files in parallel files.parallelStream().forEach(file -> { try { Path relativePath = sourceDir.relativize(file); Path targetFile = targetDir.resolve(relativePath); // Ensure target directory exists Files.createDirectories(targetFile.getParent()); // Copy with zero-copy where possible Files.copy(file, targetFile, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES); } catch (IOException e) { System.err.println("Error processing file: " + file + " - " + e.getMessage()); } }); System.out.printf("Processed %d files%n", files.size()); } } // File system monitoring with zero-copy operations public static class FileSystemWatcher { private final Path watchDir; private final Path targetDir; private volatile boolean watching; public FileSystemWatcher(Path watchDir, Path targetDir) { this.watchDir = watchDir; this.targetDir = targetDir; } public void startWatching() throws IOException { watching = true; try (WatchService watchService = FileSystems.getDefault().newWatchService()) { watchDir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY); System.out.println("Watching directory: " + watchDir); while (watching) { WatchKey key; try { key = watchService.take(); } catch (InterruptedException e) { break; } for (WatchEvent<?> event : key.pollEvents()) { if (event.kind() == StandardWatchEventKinds.OVERFLOW) { continue; } @SuppressWarnings("unchecked") WatchEvent<Path> pathEvent = (WatchEvent<Path>) event; Path filename = pathEvent.context(); Path sourceFile = watchDir.resolve(filename); Path targetFile = targetDir.resolve(filename); handleFileEvent(sourceFile, targetFile, event.kind()); } boolean valid = key.reset(); if (!valid) { break; } } } } private void handleFileEvent(Path sourceFile, Path targetFile, WatchEvent.Kind<?> kind) { try { if (kind == StandardWatchEventKinds.ENTRY_CREATE || kind == StandardWatchEventKinds.ENTRY_MODIFY) { if (Files.isRegularFile(sourceFile)) { // Use zero-copy for file operations Files.copy(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES); System.out.printf("Copied: %s -> %s%n", sourceFile, targetFile); } } } catch (IOException e) { System.err.println("Error handling file event: " + e.getMessage()); } } public void stopWatching() { watching = false; } } public static void main(String[] args) throws IOException { // Create test directories Path sourceDir = Paths.get("test_source"); Path targetDir = Paths.get("test_target"); Path watchDir = Paths.get("test_watch"); Files.createDirectories(sourceDir); Files.createDirectories(targetDir); Files.createDirectories(watchDir); // Create test files for (int i = 0; i < 5; i++) { Path testFile = sourceDir.resolve("file" + i + ".dat"); createTestFile(testFile, 10 * 1024 * 1024); // 10MB each } System.out.println("=== NIO.2 Zero-Copy Operations ==="); // Test Files.copy Path singleSource = sourceDir.resolve("file0.dat"); Path singleTarget = targetDir.resolve("file0_copy.dat"); filesCopyZeroCopy(singleSource, singleTarget); // Test copy with attributes Path attributedTarget = targetDir.resolve("file0_attributed.dat"); copyWithAttributes(singleSource, attributedTarget); // Test directory copy System.out.println("\n=== Directory Tree Copy ==="); Path copiedDir = Paths.get("test_copied"); copyDirectoryTree(sourceDir, copiedDir); // Test bulk processing System.out.println("\n=== Bulk File Processing ==="); BulkFileProcessor processor = new BulkFileProcessor(sourceDir, targetDir); processor.processFiles(); // Test file move System.out.println("\n=== File Move Test ==="); Path moveSource = sourceDir.resolve("file1.dat"); Path moveTarget = targetDir.resolve("file1_moved.dat"); atomicMove(moveSource, moveTarget); // Cleanup deleteRecursive(sourceDir); deleteRecursive(targetDir); deleteRecursive(copiedDir); deleteRecursive(watchDir); } private static void createTestFile(Path path, long size) throws IOException { try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); for (int i = 0; i < bytesToWrite; i++) { buffer.put((byte) (i % 256)); } buffer.flip(); channel.write(buffer); bytesWritten += bytesToWrite; } } } private static void deleteRecursive(Path path) throws IOException { if (Files.exists(path)) { Files.walk(path) .sorted(Comparator.reverseOrder()) .forEach(p -> { try { Files.delete(p); } catch (IOException e) { // Ignore, might be already deleted } }); } } }

Performance Benchmarks

Comprehensive Performance Testing

import java.io.*; import java.nio.*; import java.nio.channels.*; import java.nio.file.*; import java.util.concurrent.*; import java.util.stream.*; public class ZeroCopyBenchmarks { // Comprehensive benchmark of different copy methods public static void benchmarkAllMethods(Path source, Path baseTarget, long fileSize) throws IOException { System.out.printf("=== Benchmarking file size: %d MB ===%n", fileSize / (1024 * 1024)); // 1. Traditional stream copy Path target1 = baseTarget.resolve("stream_copy.dat"); long streamTime = measureTime(() -> { try { traditionalStreamCopy(source, target1); } catch (IOException e) { throw new RuntimeException(e); } }); // 2. Buffered stream copy Path target2 = baseTarget.resolve("buffered_copy.dat"); long bufferedTime = measureTime(() -> { try { bufferedStreamCopy(source, target2); } catch (IOException e) { throw new RuntimeException(e); } }); // 3. NIO channel copy with heap buffer Path target3 = baseTarget.resolve("nio_heap_copy.dat"); long nioHeapTime = measureTime(() -> { try { nioChannelCopy(source, target3, false); } catch (IOException e) { throw new RuntimeException(e); } }); // 4. NIO channel copy with direct buffer Path target4 = baseTarget.resolve("nio_direct_copy.dat"); long nioDirectTime = measureTime(() -> { try { nioChannelCopy(source, target4, true); } catch (IOException e) { throw new RuntimeException(e); } }); // 5. Zero-copy transferTo Path target5 = baseTarget.resolve("transferTo_copy.dat"); long transferToTime = measureTime(() -> { try { transferToCopy(source, target5); } catch (IOException e) { throw new RuntimeException(e); } }); // 6. Files.copy Path target6 = baseTarget.resolve("files_copy.dat"); long filesCopyTime = measureTime(() -> { try { Files.copy(source, target6, StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { throw new RuntimeException(e); } }); // Print results System.out.printf("Traditional stream: %8d ms%n", streamTime); System.out.printf("Buffered stream: %8d ms%n", bufferedTime); System.out.printf("NIO channel (heap): %8d ms%n", nioHeapTime); System.out.printf("NIO channel (direct): %8d ms%n", nioDirectTime); System.out.printf("transferTo zero-copy: %8d ms%n", transferToTime); System.out.printf("Files.copy: %8d ms%n", filesCopyTime); // Calculate improvements System.out.println("\n=== Performance Improvements ==="); System.out.printf("transferTo vs stream: %.2fx faster%n", (double) streamTime / transferToTime); System.out.printf("transferTo vs buffered: %.2fx faster%n", (double) bufferedTime / transferToTime); System.out.printf("transferTo vs NIO direct: %.2fx faster%n", (double) nioDirectTime / transferToTime); // Cleanup Files.deleteIfExists(target1); Files.deleteIfExists(target2); Files.deleteIfExists(target3); Files.deleteIfExists(target4); Files.deleteIfExists(target5); Files.deleteIfExists(target6); } // Memory usage benchmark public static void benchmarkMemoryUsage(Path source, int iterations) throws IOException { System.out.println("\n=== Memory Usage Benchmark ==="); long fileSize = Files.size(source); Runtime runtime = Runtime.getRuntime(); // Force GC before measurement System.gc(); long initialMemory = runtime.totalMemory() - runtime.freeMemory(); // Test traditional stream copy memory usage for (int i = 0; i < iterations; i++) { Path target = Paths.get("memory_test_" + i + ".dat"); traditionalStreamCopy(source, target); Files.deleteIfExists(target); } long afterStreamMemory = runtime.totalMemory() - runtime.freeMemory(); long streamMemoryUsed = afterStreamMemory - initialMemory; // Force GC again System.gc(); long resetMemory = runtime.totalMemory() - runtime.freeMemory(); // Test zero-copy memory usage for (int i = 0; i < iterations; i++) { Path target = Paths.get("memory_test_" + i + ".dat"); transferToCopy(source, target); Files.deleteIfExists(target); } long afterZeroCopyMemory = runtime.totalMemory() - runtime.freeMemory(); long zeroCopyMemoryUsed = afterZeroCopyMemory - resetMemory; System.out.printf("File size: %d MB%n", fileSize / (1024 * 1024)); System.out.printf("Traditional stream memory used: %d KB%n", streamMemoryUsed / 1024); System.out.printf("Zero-copy memory used: %d KB%n", zeroCopyMemoryUsed / 1024); System.out.printf("Memory reduction: %.2fx less memory%n", (double) streamMemoryUsed / zeroCopyMemoryUsed); } // Concurrent access benchmark public static void benchmarkConcurrentAccess(Path source, Path targetDir, int threadCount) throws IOException, InterruptedException { System.out.println("\n=== Concurrent Access Benchmark ==="); ExecutorService executor = Executors.newFixedThreadPool(threadCount); CountDownLatch startLatch = new CountDownLatch(1); CountDownLatch endLatch = new CountDownLatch(threadCount); List<Long> times = new CopyOnWriteArrayList<>(); for (int i = 0; i < threadCount; i++) { final int threadId = i; executor.submit(() -> { try { startLatch.await(); Path target = targetDir.resolve("concurrent_copy_" + threadId + ".dat"); long startTime = System.nanoTime(); transferToCopy(source, target); long endTime = System.nanoTime(); times.add(endTime - startTime); endLatch.countDown(); } catch (Exception e) { e.printStackTrace(); } }); } // Start all threads simultaneously startLatch.countDown(); // Wait for completion endLatch.await(); executor.shutdown(); // Calculate statistics LongSummaryStatistics stats = times.stream() .mapToLong(Long::longValue) .map(t -> t / 1_000_000) // Convert to milliseconds .summaryStatistics(); System.out.printf("Thread count: %d%n", threadCount); System.out.printf("Average time: %.2f ms%n", stats.getAverage()); System.out.printf("Best time: %d ms%n", stats.getMin()); System.out.printf("Worst time: %d ms%n", stats.getMax()); System.out.printf("Total throughput: %.2f MB/s%n", (threadCount * Files.size(source) / (1024.0 * 1024.0)) / (stats.getSum() / 1000.0)); // Cleanup Files.walk(targetDir) .filter(Files::isRegularFile) .forEach(path -> { try { Files.delete(path); } catch (IOException e) { // Ignore } }); } // Helper methods private static long measureTime(Runnable operation) { long startTime = System.nanoTime(); operation.run(); return (System.nanoTime() - startTime) / 1_000_000; } private static void traditionalStreamCopy(Path source, Path target) throws IOException { try (InputStream in = Files.newInputStream(source); OutputStream out = Files.newOutputStream(target)) { byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); } } } private static void bufferedStreamCopy(Path source, Path target) throws IOException { try (BufferedInputStream in = new BufferedInputStream(Files.newInputStream(source)); BufferedOutputStream out = new BufferedOutputStream(Files.newOutputStream(target))) { byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); } } } private static void nioChannelCopy(Path source, Path target, boolean useDirectBuffer) throws IOException { try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = useDirectBuffer ? ByteBuffer.allocateDirect(8192) : ByteBuffer.allocate(8192); while (sourceChannel.read(buffer) != -1) { buffer.flip(); targetChannel.write(buffer); buffer.clear(); } } } private static void transferToCopy(Path source, Path target) throws IOException { try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { sourceChannel.transferTo(0, sourceChannel.size(), targetChannel); } } public static void main(String[] args) throws Exception { Path benchmarkDir = Paths.get("benchmark_files"); Files.createDirectories(benchmarkDir); // Test different file sizes long[] fileSizes = { 10 * 1024 * 1024, // 10MB 100 * 1024 * 1024, // 100MB 500 * 1024 * 1024 // 500MB }; for (long fileSize : fileSizes) { Path sourceFile = benchmarkDir.resolve("test_" + fileSize + ".dat"); createTestFile(sourceFile, fileSize); benchmarkAllMethods(sourceFile, benchmarkDir, fileSize); // Memory benchmark for medium-sized file if (fileSize == 100 * 1024 * 1024) { benchmarkMemoryUsage(sourceFile, 10); } Files.deleteIfExists(sourceFile); } // Concurrent benchmark Path concurrentSource = benchmarkDir.resolve("concurrent_test.dat"); createTestFile(concurrentSource, 50 * 1024 * 1024); // 50MB int[] threadCounts = {2, 4, 8, 16}; for (int threads : threadCounts) { benchmarkConcurrentAccess(concurrentSource, benchmarkDir, threads); } Files.deleteIfExists(concurrentSource); Files.deleteIfExists(benchmarkDir); } private static void createTestFile(Path path, long size) throws IOException { System.out.printf("Creating test file: %d MB%n", size / (1024 * 1024)); try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); for (int i = 0; i < bytesToWrite; i++) { buffer.put((byte) (i % 256)); } buffer.flip(); channel.write(buffer); bytesWritten += bytesToWrite; } } } }

Best Practices

Production-Ready Zero-Copy Implementation

import java.io.*; import java.nio.*; import java.nio.channels.*; import java.nio.file.*; import java.util.concurrent.*; import java.util.concurrent.atomic.*; public class ZeroCopyBestPractices { // Production-ready file transfer service public static class ZeroCopyFileTransferService { private final ExecutorService executor; private final DirectBufferPool bufferPool; private final AtomicLong totalBytesTransferred; private final AtomicLong totalOperations; public ZeroCopyFileTransferService(int threadPoolSize, int bufferPoolSize, int bufferSize) { this.executor = Executors.newFixedThreadPool(threadPoolSize, new ThreadFactory() { private final AtomicLong counter = new AtomicLong(); @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, "zero-copy-worker-" + counter.incrementAndGet()); thread.setDaemon(true); return thread; } }); this.bufferPool = new DirectBufferPool(bufferPoolSize, bufferSize); this.totalBytesTransferred = new AtomicLong(); this.totalOperations = new AtomicLong(); } public CompletableFuture<Long> transferFile(Path source, Path target) { return CompletableFuture.supplyAsync(() -> { try { long startTime = System.nanoTime(); long bytesTransferred = performTransfer(source, target); long endTime = System.nanoTime(); totalBytesTransferred.addAndGet(bytesTransferred); totalOperations.incrementAndGet(); long durationMs = (endTime - startTime) / 1_000_000; System.out.printf("Transfer completed: %s -> %s (%d bytes, %d ms)%n", source, target, bytesTransferred, durationMs); return bytesTransferred; } catch (IOException e) { throw new CompletionException(e); } }, executor); } public CompletableFuture<Void> transferFiles(List<Path> sources, Path targetDir) { List<CompletableFuture<Long>> futures = sources.stream() .map(source -> { Path target = targetDir.resolve(source.getFileName()); return transferFile(source, target); }) .toList(); return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])); } private long performTransfer(Path source, Path target) throws IOException { // Try zero-copy first try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long fileSize = sourceChannel.size(); long transferred = sourceChannel.transferTo(0, fileSize, targetChannel); // Verify complete transfer if (transferred != fileSize) { throw new IOException("Incomplete transfer: " + transferred + " of " + fileSize); } return transferred; } catch (IOException e) { // Fall back to buffered copy if zero-copy fails System.err.printf("Zero-copy failed for %s, falling back to buffered copy: %s%n", source, e.getMessage()); return fallbackBufferedCopy(source, target); } } private long fallbackBufferedCopy(Path source, Path target) throws IOException { try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long fileSize = sourceChannel.size(); long bytesCopied = 0; while (bytesCopied < fileSize) { ByteBuffer buffer = bufferPool.acquire(); try { buffer.clear(); int bytesRead = sourceChannel.read(buffer); if (bytesRead == -1) break; buffer.flip(); while (buffer.hasRemaining()) { bytesCopied += targetChannel.write(buffer); } } finally { bufferPool.release(buffer); } } return bytesCopied; } } public TransferStats getStats() { return new TransferStats( totalOperations.get(), totalBytesTransferred.get(), System.currentTimeMillis() ); } public void shutdown() { executor.shutdown(); try { if (!executor.awaitTermination(5, TimeUnit.SECONDS)) { executor.shutdownNow(); } } catch (InterruptedException e) { executor.shutdownNow(); Thread.currentThread().interrupt(); } bufferPool.cleanup(); } public record TransferStats(long totalOperations, long totalBytes, long timestamp) { public double getAverageBytesPerOperation() { return totalOperations > 0 ? (double) totalBytes / totalOperations : 0; } @Override public String toString() { return String.format( "TransferStats{operations=%d, bytes=%.2f MB, avg=%.2f MB/op}", totalOperations, totalBytes / (1024.0 * 1024.0), getAverageBytesPerOperation() / (1024.0 * 1024.0) ); } } } // Error handling and recovery public static class ResilientFileTransfer { private final int maxRetries; private final long retryDelayMs; public ResilientFileTransfer(int maxRetries, long retryDelayMs) { this.maxRetries = maxRetries; this.retryDelayMs = retryDelayMs; } public long transferWithRetry(Path source, Path target) throws IOException { IOException lastException = null; for (int attempt = 1; attempt <= maxRetries; attempt++) { try { return performZeroCopyTransfer(source, target); } catch (IOException e) { lastException = e; System.err.printf("Transfer attempt %d failed: %s%n", attempt, e.getMessage()); if (attempt < maxRetries) { try { Thread.sleep(retryDelayMs); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); throw new IOException("Transfer interrupted", ie); } // Clean up partial file before retry try { Files.deleteIfExists(target); } catch (IOException deleteError) { // Ignore cleanup errors } } } } throw new IOException("All transfer attempts failed", lastException); } private long performZeroCopyTransfer(Path source, Path target) throws IOException { try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ); FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { long fileSize = Files.size(source); long transferred = 0; // Use chunked transfer for very large files long chunkSize = 256 * 1024 * 1024; // 256MB chunks while (transferred < fileSize) { long remaining = fileSize - transferred; long bytesToTransfer = Math.min(chunkSize, remaining); long chunkTransferred = sourceChannel.transferTo( transferred, bytesToTransfer, targetChannel); if (chunkTransferred == 0) { throw new IOException("Zero bytes transferred, possible disk full"); } transferred += chunkTransferred; } // Verify file integrity verifyTransfer(source, target); return transferred; } } private void verifyTransfer(Path source, Path target) throws IOException { long sourceSize = Files.size(source); long targetSize = Files.size(target); if (sourceSize != targetSize) { throw new IOException(String.format( "Size mismatch: source=%d, target=%d", sourceSize, targetSize)); } // For critical applications, add checksum verification if (sourceSize < 100 * 1024 * 1024) { // Only for smaller files long sourceChecksum = computeChecksum(source); long targetChecksum = computeChecksum(target); if (sourceChecksum != targetChecksum) { throw new IOException("Checksum mismatch"); } } } private long computeChecksum(Path file) throws IOException { // Simple checksum implementation try (InputStream in = Files.newInputStream(file)) { long checksum = 0; byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { for (int i = 0; i < bytesRead; i++) { checksum = (checksum * 31) + (buffer[i] & 0xFF); } } return checksum; } } } // Monitoring and metrics public static class TransferMonitor { private final AtomicLong successfulTransfers = new AtomicLong(); private final AtomicLong failedTransfers = new AtomicLong(); private final AtomicLong totalBytes = new AtomicLong(); private final LongAdder totalTransferTime = new LongAdder(); public void recordSuccess(long bytes, long durationNanos) { successfulTransfers.incrementAndGet(); totalBytes.addAndGet(bytes); totalTransferTime.add(durationNanos); } public void recordFailure() { failedTransfers.incrementAndGet(); } public MonitoringStats getStats() { long success = successfulTransfers.get(); long failure = failedTransfers.get(); long totalOps = success + failure; double successRate = totalOps > 0 ? (double) success / totalOps * 100 : 0; long avgTransferTime = success > 0 ? totalTransferTime.longValue() / success : 0; double throughput = avgTransferTime > 0 ? (totalBytes.get() / (1024.0 * 1024.0)) / (avgTransferTime / 1_000_000_000.0) : 0; return new MonitoringStats( totalOps, success, failure, successRate, totalBytes.get(), avgTransferTime / 1_000_000, // Convert to ms throughput ); } public record MonitoringStats( long totalOperations, long successfulOperations, long failedOperations, double successRate, long totalBytes, long averageTimeMs, double throughputMBs ) { @Override public String toString() { return String.format( "MonitoringStats{ops=%d, success=%.1f%%, bytes=%.2f MB, avgTime=%d ms, throughput=%.2f MB/s}", totalOperations, successRate, totalBytes / (1024.0 * 1024.0), averageTimeMs, throughputMBs ); } } } public static void main(String[] args) throws Exception { // Create test environment Path testDir = Paths.get("production_test"); Files.createDirectories(testDir); // Create test files List<Path> testFiles = new ArrayList<>(); for (int i = 0; i < 10; i++) { Path testFile = testDir.resolve("source_" + i + ".dat"); createTestFile(testFile, 10 * 1024 * 1024); // 10MB each testFiles.add(testFile); } System.out.println("=== Production-Ready Zero-Copy Implementation ==="); // Initialize service ZeroCopyFileTransferService service = new ZeroCopyFileTransferService( 4, // 4 threads 10, // 10 buffers in pool 64 * 1024 // 64KB buffer size ); TransferMonitor monitor = new TransferMonitor(); // Perform transfers Path targetDir = testDir.resolve("target"); Files.createDirectories(targetDir); List<CompletableFuture<Long>> futures = testFiles.stream() .map(source -> { Path target = targetDir.resolve(source.getFileName()); return service.transferFile(source, target) .whenComplete((bytes, error) -> { if (error == null) { monitor.recordSuccess(bytes, 0); // Duration not tracked in this example } else { monitor.recordFailure(); } }); }) .toList(); // Wait for completion CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get(); // Print stats System.out.println("Service stats: " + service.getStats()); System.out.println("Monitor stats: " + monitor.getStats()); // Test resilient transfer System.out.println("\n=== Resilient Transfer Test ==="); ResilientFileTransfer resilientTransfer = new ResilientFileTransfer(3, 1000); Path resilientSource = testDir.resolve("resilient_source.dat"); Path resilientTarget = testDir.resolve("resilient_target.dat"); createTestFile(resilientSource, 5 * 1024 * 1024); long transferred = resilientTransfer.transferWithRetry(resilientSource, resilientTarget); System.out.printf("Resilient transfer completed: %d bytes%n", transferred); // Cleanup service.shutdown(); deleteRecursive(testDir); } private static void createTestFile(Path path, long size) throws IOException { try (FileChannel channel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); long bytesWritten = 0; while (bytesWritten < size) { buffer.clear(); int bytesToWrite = (int) Math.min(buffer.capacity(), size - bytesWritten); buffer.limit(bytesToWrite); for (int i = 0; i < bytesToWrite; i++) { buffer.put((byte) (i % 256)); } buffer.flip(); channel.write(buffer); bytesWritten += bytesToWrite; } } } private static void deleteRecursive(Path path) throws IOException { if (Files.exists(path)) { Files.walk(path) .sorted((a, b) -> -a.compareTo(b)) // Reverse order for deletion .forEach(p -> { try { Files.delete(p); } catch (IOException e) { // Ignore cleanup errors } }); } } }

Summary

Zero-copy data transfer in Java provides significant performance benefits for I/O-intensive applications. Key takeaways:

  1. Use FileChannel.transferTo()/transferFrom() for file-to-file and file-to-network transfers
  2. Memory-mapped files provide efficient random access to large files
  3. Direct ByteBuffers reduce copying between JVM and native memory
  4. NIO.2 operations like Files.copy() often use zero-copy internally
  5. Proper resource management is crucial for production use
  6. Monitoring and metrics help optimize zero-copy implementations

By following these patterns and best practices, you can build high-performance, efficient data transfer systems in Java that minimize memory usage and CPU overhead.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper