NIO Overview

// ── NIO vs IO — the fundamental difference in code style ─────────────

// java.io style: stream-oriented, blocking, byte-at-a-time
try (InputStream is = new FileInputStream("data.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
    String line;
    while ((line = br.readLine()) != null) {
        process(line);
    }
}

// NIO style: buffer-oriented, channels, explicit position management
try (FileChannel channel = FileChannel.open(Path.of("data.txt"))) {
    ByteBuffer buffer = ByteBuffer.allocate(4096);
    while (channel.read(buffer) != -1) {  // read into buffer
        buffer.flip();                     // switch from write mode to read mode
        while (buffer.hasRemaining()) {
            byte b = buffer.get();         // read from buffer
            process(b);
        }
        buffer.clear();                    // switch back to write mode
    }
}

// ── The four I/O models in NIO ────────────────────────────────────────

// 1. Blocking I/O (default channel behavior — same as java.io):
try (FileChannel fc = FileChannel.open(Path.of("file.txt"))) {
    ByteBuffer buf = ByteBuffer.allocate(1024);
    fc.read(buf);   // blocks until data is available or end of stream
}

// 2. Non-blocking I/O (selector-based, for network channels):
SocketChannel sc = SocketChannel.open();
sc.configureBlocking(false);   // switch to non-blocking mode
sc.connect(new InetSocketAddress("localhost", 8080));
// read() now returns 0 if no data, -1 at end — never blocks

// 3. Memory-mapped I/O (zero-copy file access):
try (FileChannel fc = FileChannel.open(Path.of("large.bin"))) {
    MappedByteBuffer mapped = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
    // File content accessible directly from virtual memory — no copy to Java heap
    int firstInt = mapped.getInt();
}

// 4. Asynchronous I/O (NIO.2, Java 7+):
AsynchronousFileChannel afc = AsynchronousFileChannel.open(Path.of("async.txt"));
ByteBuffer buf = ByteBuffer.allocate(1024);
afc.read(buf, 0, null, new CompletionHandler<Integer, Void>() {
    public void completed(Integer result, Void attachment) {
        System.out.println("Read " + result + " bytes asynchronously");
    }
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
    }
});
// Calling thread continues immediately — callback fires when read completes

// ── Selector — one thread, many connections ───────────────────────────
Selector selector = Selector.open();

ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.bind(new InetSocketAddress(8080));
server.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();   // blocks until at least one channel is ready
    Set<SelectionKey> keys = selector.selectedKeys();
    Iterator<SelectionKey> it = keys.iterator();

    while (it.hasNext()) {
        SelectionKey key = it.next();
        it.remove();   // MUST remove — selector doesn't do this automatically

        if (key.isAcceptable()) {
            SocketChannel client = ((ServerSocketChannel) key.channel()).accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer readBuf = ByteBuffer.allocate(1024);
            int n = client.read(readBuf);
            if (n == -1) { client.close(); } else { handleRequest(readBuf); }
        }
    }
}

// ── Heap buffer vs direct buffer ─────────────────────────────────────
// Heap buffer: on Java heap, GC-managed, may require copy for I/O:
ByteBuffer heapBuf = ByteBuffer.allocate(4096);

// Direct buffer: off-heap native memory, no copy for I/O, slower to allocate:
ByteBuffer directBuf = ByteBuffer.allocateDirect(4096);

// Performance impact for large file copying:
Path src  = Path.of("large-file.bin");
Path dst  = Path.of("output.bin");

// With heap buffer: JVM allocates temp direct buffer per read/write
long start = System.nanoTime();
try (FileChannel in  = FileChannel.open(src);
     FileChannel out = FileChannel.open(dst,
         StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
    ByteBuffer heap = ByteBuffer.allocate(65536);
    while (in.read(heap) != -1) { heap.flip(); out.write(heap); heap.clear(); }
}
System.out.printf("Heap buffer: %.0f ms%n", (System.nanoTime()-start)/1e6);

// With direct buffer: single DMA path, no intermediate copy:
start = System.nanoTime();
try (FileChannel in  = FileChannel.open(src);
     FileChannel out = FileChannel.open(dst,
         StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
    ByteBuffer direct = ByteBuffer.allocateDirect(65536);
    while (in.read(direct) != -1) { direct.flip(); out.write(direct); direct.clear(); }
}
System.out.printf("Direct buffer: %.0f ms%n", (System.nanoTime()-start)/1e6);

// FileChannel.transferTo — zero-copy at OS level (sendfile() on Linux):
try (FileChannel in  = FileChannel.open(src);
     FileChannel out = FileChannel.open(dst,
         StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
    in.transferTo(0, in.size(), out);  // OS-level zero-copy
}
System.out.printf("transferTo: %.0f ms%n", (System.nanoTime()-start)/1e6); // fastest

// ── Scatter/gather I/O ────────────────────────────────────────────────
// Protocol: 4-byte length header + variable body
ByteBuffer header = ByteBuffer.allocateDirect(4);
ByteBuffer body   = ByteBuffer.allocateDirect(1024);

try (SocketChannel sc = SocketChannel.open(new InetSocketAddress("host", 8080))) {
    // Scatter read: fill header first, then body, in ONE system call:
    ByteBuffer[] buffers = {header, body};
    long totalRead = sc.read(buffers);   // reads into header until full, then body

    header.flip();
    int bodyLength = header.getInt();   // read the 4-byte length prefix

    body.flip();
    byte[] bodyBytes = new byte[bodyLength];
    body.get(bodyBytes);

    // Gather write: write header + body in ONE system call:
    header.clear();
    header.putInt(responseBody.length);
    header.flip();
    ByteBuffer responseBodyBuf = ByteBuffer.wrap(responseBody);
    sc.write(new ByteBuffer[]{header, responseBodyBuf});  // single writev() call
}

// ── NIO.2 as entry point to NIO channels ─────────────────────────────
// Files.newByteChannel — SeekableByteChannel with explicit OpenOptions:
try (SeekableByteChannel sbc = Files.newByteChannel(
        Path.of("data.bin"),
        StandardOpenOption.READ,
        StandardOpenOption.WRITE)) {  // can't do both with FileInputStream
    ByteBuffer buf = ByteBuffer.allocate(512);
    sbc.read(buf);          // read from current position
    sbc.position(0);        // seek to start
    buf.flip();
    sbc.write(buf);         // write modified content back
}

// ── Asynchronous file I/O (NIO.2) ─────────────────────────────────────
try (AsynchronousFileChannel afc = AsynchronousFileChannel.open(
        Path.of("async.bin"), StandardOpenOption.READ)) {

    ByteBuffer buf = ByteBuffer.allocate(4096);
    CompletableFuture<Integer> promise = new CompletableFuture<>();

    afc.read(buf, 0, null, new CompletionHandler<Integer, Void>() {
        public void completed(Integer bytesRead, Void att) {
            buf.flip();
            promise.complete(bytesRead);
        }
        public void failed(Throwable ex, Void att) {
            promise.completeExceptionally(ex);
        }
    });

    // Calling thread is free — not blocked:
    doOtherWork();

    // Retrieve result when needed:
    int n = promise.get(5, TimeUnit.SECONDS);
    System.out.println("Read " + n + " bytes asynchronously");
}

// ── Decision guide: which API for which problem ──────────────────────

// Case 1: Read a config file, parse, done
// ANSWER: java.io with NIO.2 entry point
String config = Files.readString(Path.of("config.json"), StandardCharsets.UTF_8);

// Case 2: Process a 50GB log file line by line
// ANSWER: java.io stream, NIO.2 path
try (Stream<String> lines = Files.lines(Path.of("app.log"), StandardCharsets.UTF_8)) {
    lines.filter(l -> l.contains("ERROR")).forEach(System.out::println);
}

// Case 3: Copy a 10GB file as fast as possible
// ANSWER: NIO FileChannel.transferTo (zero-copy sendfile)
try (FileChannel in  = FileChannel.open(Path.of("src.bin"));
     FileChannel out = FileChannel.open(Path.of("dst.bin"),
         StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    long total = in.size();
    long transferred = 0;
    while (transferred < total) {
        transferred += in.transferTo(transferred, total - transferred, out);
    }
}

// Case 4: Random access to a binary database file (seeks, reads, writes)
// ANSWER: NIO FileChannel (seekable, readable+writable)
try (FileChannel fc = FileChannel.open(Path.of("db.bin"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    fc.position(recordIndex * RECORD_SIZE);    // seek to record
    ByteBuffer record = ByteBuffer.allocate(RECORD_SIZE);
    fc.read(record);     // read record
    record.flip();
    int id = record.getInt();
    // Modify and write back:
    record.clear();
    record.putInt(newId);
    record.flip();
    fc.position(recordIndex * RECORD_SIZE);
    fc.write(record);
}

// Case 5: Server handling 10,000 concurrent HTTP connections
// ANSWER: NIO Selector or virtual threads (Java 21)
// Option A: NIO Selector (pre-Java 21, maximum scalability)
Selector selector = Selector.open();
// ... register channels, event loop as shown above

// Option B: Virtual threads (Java 21+, simplest for new code)
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    ServerSocket server = new ServerSocket(8080);
    while (true) {
        Socket client = server.accept();
        executor.submit(() -> handleClient(client));  // blocking I/O, virtual thread unmounts
    }
}

// Case 6: Watch a directory for file changes (CI/CD, hot reload)
// ANSWER: NIO.2 WatchService
try (WatchService watcher = FileSystems.getDefault().newWatchService()) {
    Path dir = Path.of("/conf");
    dir.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
    WatchKey key;
    while ((key = watcher.take()) != null) {
        key.pollEvents().forEach(e ->
            System.out.println("Changed: " + e.context())
        );
        key.reset();
    }
}

// ── Performance profile: when each NIO feature pays off ──────────────
// Buffers vs streams:
//   Buffered streams amortize system calls — good enough for most cases
//   NIO buffers add direct buffer option — eliminates heap-to-native copy
//   Break-even: only matters for >100MB/s throughput or latency < 1ms target

// FileChannel.transferTo:
//   Eliminates all user-space copies for file-to-file or file-to-socket
//   On Linux: maps to sendfile() — kernel copies between file descriptors
//   Speedup: 2-5x for large file copying vs buffered stream copy

// Memory-mapped I/O:
//   Best for random-access patterns on large files (>100MB)
//   Latency for first access to a page: 0.1ms (cold) to <1µs (hot)
//   Sequential large-file reads: comparable to transferTo
//   Bad fit: files that don't fit in virtual address space (>4GB on 32-bit JVMs)

// Selector-based non-blocking:
//   Needed when: threads > 1000 concurrent connections is unacceptable
//   Virtual threads (Java 21+) eliminate this need for most use cases
//   Selector still relevant for extreme scale (>100k connections/process)