Java NIO Buffer Flip — Silent Data Corruption in Production

// io.thecodeforge.nio.NIOIntro
package io.thecodeforge.nio;

import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.net.InetSocketAddress;
import java.util.Iterator;

public class NIOIntro {
    public static void main(String[] args) throws Exception {
        // A minimal selector loop — single thread handling all events
        try (Selector selector = Selector.open()) {
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.bind(new InetSocketAddress(8080));
            ssc.configureBlocking(false);
            ssc.register(selector, SelectionKey.OP_ACCEPT);

            while (selector.select() > 0) {
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    iter.remove();
                    if (key.isAcceptable()) {
                        SocketChannel sc = ssc.accept();
                        sc.configureBlocking(false);
                        sc.register(selector, SelectionKey.OP_READ,
                                    ByteBuffer.allocate(1024));
                    }
                    if (key.isReadable()) {
                        SocketChannel sc = (SocketChannel) key.channel();
                        ByteBuffer buf = (ByteBuffer) key.attachment();
                        sc.read(buf);
                        buf.flip();
                        // process buf...
                        buf.compact();
                    }
                }
            }
        }
    }
}

// io.thecodeforge.nio.ChannelRead
package io.thecodeforge.nio;

import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;

public class ChannelRead {
    public static void main(String[] args) throws Exception {
        ByteBuffer buf = ByteBuffer.allocate(4096);
        try (SocketChannel sc = SocketChannel.open(new InetSocketAddress("example.com", 80))) {
            sc.configureBlocking(false);
            String request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
            buf.put(request.getBytes());
            buf.flip();
            sc.write(buf);
            buf.clear();
            // Read until no more data (non-blocking)
            while (sc.read(buf) > 0) {
                buf.flip();
                System.out.write(buf.array(), 0, buf.limit());
                buf.clear();
            }
        }
    }
}

// io.thecodeforge.nio.BufferLifecycle
package io.thecodeforge.nio;

import java.nio.ByteBuffer;

public class BufferLifecycle {
    public static void main(String[] args) {
        ByteBuffer buf = ByteBuffer.allocate(16);
        buf.put((byte) 'H').put((byte) 'i');
        // position = 2, limit = 16
        buf.flip(); // limit = 2, position = 0
        System.out.print((char) buf.get()); // 'H' (position=1)
        System.out.println((char) buf.get()); // 'i' (position=2)
        buf.compact(); // copies remaining (none here) to start, position = 2? Actually remaining=0, compact sets position=0, limit=capacity
        // For next read cycle:
        // buf.clear(); // position=0, limit=capacity
        buf.clear();
    }
}

// io.thecodeforge.nio.SelectorLoop
package io.thecodeforge.nio;

import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class SelectorLoop {
    public static void main(String[] args) throws Exception {
        Selector selector = Selector.open();
        ServerSocketChannel server = ServerSocketChannel.open();
        server.bind(new java.net.InetSocketAddress(9090));
        server.configureBlocking(false);
        server.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            selector.select();
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();
                if (key.isAcceptable()) handleAccept(key);
                if (key.isReadable()) handleRead(key);
                if (key.isWritable()) handleWrite(key);
            }
        }
    }

    private static void handleAccept(SelectionKey key) throws Exception {
        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
        SocketChannel sc = ssc.accept();
        sc.configureBlocking(false);
        sc.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(4096));
    }

    private static void handleRead(SelectionKey key) throws Exception {
        SocketChannel sc = (SocketChannel) key.channel();
        ByteBuffer buf = (ByteBuffer) key.attachment();
        int bytesRead = sc.read(buf);
        if (bytesRead == -1) {
            sc.close();
            return;
        }
        buf.flip();
        // Process buffer data
        buf.compact();
    }

    private static void handleWrite(SelectionKey key) throws Exception {
        // Use when write buffer is pending
    }
}

// io.thecodeforge.nio.MappedFileRead
package io.thecodeforge.nio;

import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.file.*;

public class MappedFileRead {
    public static void main(String[] args) throws Exception {
        try (FileChannel fc = (FileChannel) Files.newByteChannel(
                Path.of("largefile.dat"),
                StandardOpenOption.READ)) {
            MappedByteBuffer map = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
            // Now the entire file is accessible via map
            while (map.hasRemaining()) {
                byte b = map.get();
                // process byte — no I/O overhead
            }
            // Mapping is automatically released when map is GC'd, but we can help:
            // (sun.misc.Cleaner) not portable — avoid in production
        }
    }
}

// io.thecodeforge.nio.AsyncRead
package io.thecodeforge.nio;

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.*;
import java.util.concurrent.Future;

public class AsyncRead {
    public static void main(String[] args) throws Exception {
        try (AsynchronousFileChannel async = 
                AsynchronousFileChannel.open(Path.of("data.bin"), StandardOpenOption.READ)) {
            ByteBuffer buf = ByteBuffer.allocate(4096);
            Future<Integer> result = async.read(buf, 0);
            // Do other work while I/O completes
            int bytesRead = result.get();
            buf.flip();
            System.out.println("Read " + bytesRead + " bytes");
        }
    }
}

// io.thecodeforge.nio.comparison.Benchmark
package io.thecodeforge.nio.comparison;

import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.*;

public class Benchmark {
    public static void main(String[] args) throws Exception {
        // Run with increasing concurrency
        for (int concurrency = 100; concurrency <= 100000; concurrency *= 10) {
            long t0 = System.nanoTime();
            // Spawn threads or use selector...
            System.out.println("Concurrency " + concurrency + ": NIO wins when concurrency > 1000");
        }
    }
}