NIO

🔍 What Is It?

NIO Core Concepts:

Buffer — a fixed-size container for data

• →ByteBuffer, CharBuffer, IntBuffer, etc.
• →Key properties: capacity (total size), limit (read boundary), position (current read/write point)
• →flip() — switch from write mode to read mode
• →clear() / compact() — prepare for writing again
• →Direct ByteBuffer — off-heap memory, faster for I/O

Channel — bidirectional I/O endpoint

• →FileChannel — file I/O (also supports memory-mapped files)
• →SocketChannel — TCP client
• →ServerSocketChannel — TCP server
• →DatagramChannel — UDP

Selector — multiplex many channels on one thread

• →Non-blocking: one thread handles thousands of connections
• →SelectionKey: CONNECT, ACCEPT, READ, WRITE events
• →Foundation of event-loop frameworks (Netty, Vert.x)

Path/Files (NIO.2, Java 7+)

• →The modern file API (covered in File API topic)
• →Built on NIO concepts but with a higher-level API

🎯 Why Do We Need It?

Traditional I/O (java.io) is blocking:

• →One thread per connection
• →Thread blocks while waiting for data
• →10,000 connections = 10,000 threads = ~10GB memory

NIO is non-blocking:

• →One thread can handle thousands of connections
• →Thread only processes connections that have data ready
• →Selector tells you which channels are ready
• →Foundation of modern high-performance servers

For enterprise developers, NIO is mostly used indirectly through frameworks (Netty, Spring WebFlux). Direct NIO programming is needed for custom protocols and high-performance file operations.

🏗️ What Happens in Real Projects?

NIO in enterprise Java:

• →Netty — built entirely on NIO; powers many high-performance services
• →Spring WebFlux — reactive web framework built on Reactor Netty (NIO)
• →Memory-mapped files — FileChannel.map() for fast large file access
• →File copying — FileChannel.transferTo() for zero-copy file transfer
• →Direct ByteBuffer — off-heap memory for I/O-intensive processing

⚙️ How It Works

Buffer State Machine:

Write mode:  position=0, limit=capacity
After write: position=bytesWritten, limit=capacity

flip():      position=0, limit=bytesWritten  (ready to read)
After read:  position=bytesRead, limit=bytesWritten

clear():     position=0, limit=capacity  (ready to write again)
compact():   unread data moved to start, position=unreadBytes

Non-blocking Selector Loop:

while (true) {
    selector.select();  // blocks until at least one channel is ready
    Set<SelectionKey> keys = selector.selectedKeys();
    for (SelectionKey key : keys) {
        if (key.isAcceptable()) handleAccept(key);
        else if (key.isReadable()) handleRead(key);
        else if (key.isWritable()) handleWrite(key);
    }
    keys.clear();
}

💻 Example

NIO File Operations and Memory-Mapped Files — Practical NIO usage for high-performance file operations.

// Fast file copy using FileChannel.transferTo (zero-copy)
public void copyFile(Path source, Path dest) throws IOException {
    try (FileChannel src = FileChannel.open(source, StandardOpenOption.READ);
         FileChannel dst = FileChannel.open(dest, 
             StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
        
        src.transferTo(0, src.size(), dst);
        // transferTo uses OS-level zero-copy (sendfile on Linux)
        // Much faster than read-into-buffer-write
    }
}

// Reading with ByteBuffer
public byte[] readFile(Path path) throws IOException {
    try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
        ByteBuffer buffer = ByteBuffer.allocate((int) channel.size());
        
        while (buffer.hasRemaining()) {
            int bytesRead = channel.read(buffer);
            if (bytesRead == -1) break;  // end of file
        }
        
        buffer.flip();  // switch to read mode
        byte[] bytes = new byte[buffer.remaining()];
        buffer.get(bytes);
        return bytes;
    }
}

// Memory-mapped file — fastest way to read large files
public void processLargeFile(Path path) throws IOException {
    try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
        // Map entire file into memory (virtual memory, not necessarily RAM)
        MappedByteBuffer buffer = channel.map(
            FileChannel.MapMode.READ_ONLY, 0, channel.size()
        );
        
        // Access file content directly from buffer — no read() calls needed
        while (buffer.hasRemaining()) {
            byte b = buffer.get();  // direct memory access
            process(b);
        }
        // OS handles paging in/out as needed
    }
}

// Direct ByteBuffer — off-heap memory for I/O
// Faster for I/O because no copy between JVM heap and OS
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024 * 1024);  // 1MB off-heap
// Use for repeated I/O operations to same buffer
// Be careful: not GC'd like heap buffers, can cause native OOM

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits