Keywords: Java NIO, selector tutorial, non-blocking IO Java, Java event loop, Java concurrency

Java NIO selectors are one of the most powerful — and most misunderstood — components of the standard library.

Many developers use them for scalable systems, but very few understand what actually happens inside a selector loop under load.

This gap between API usage and system-level understanding often leads to inefficient designs, CPU spikes, and hard-to-debug performance issues.

The official Java documentation explains how to use selectors, but not how they behave internally.

As a result, developers struggle with:

• Why select() sometimes causes CPU spikes
• How non-blocking I/O actually scales
• What happens inside the event loop
• How channels interact with selectors

Understanding the internal model is essential for building high-performance systems.

A Selector allows a single thread to monitor multiple channels for I/O events:

• OP_ACCEPT → new connection
• OP_CONNECT → connection established
• OP_READ → data available
• OP_WRITE → ready to send data

👉 Instead of blocking per connection, it acts as an event multiplexer.

At the heart of NIO is the event-driven loop:

while (true) {
    selector.select();

    Set<SelectionKey> selectedKeys = selector.selectedKeys();

    for (SelectionKey key : selectedKeys) {
        if (key.isAcceptable()) {
            handleAccept(key);
        } else if (key.isReadable()) {
            handleRead(key);
        } else if (key.isWritable()) {
            handleWrite(key);
        }
    }

    selectedKeys.clear();
}