Cracking NIO Interview: An Alibaba P7 Senior Explains IO Multiplexing

The session begins with a brief on BIO (Blocking I/O): after a ServerSocket accepts a connection, each read/write blocks the thread, forcing a one‑thread‑per‑socket model that cannot scale to thousands of clients (C10K).

Moving to NIO, the interviewee explains that Java’s NIO package provides a non‑blocking API, allowing a single thread to monitor many sockets via a Selector. Sockets are registered with the selector, and the main thread blocks on Selector.select(). When a socket becomes ready, the selector wakes the thread, which can then retrieve the ready socket and process it.

Delving deeper, the kernel implementation of the classic select() system call is described. The call copies a bitmap of file descriptors (fd_set) from user space to kernel space, scans the set with O(N) complexity, and blocks the calling thread if no socket is ready. The default limit is 1024 descriptors because fd_set is a 1024‑bit bitmap; increasing this limit requires recompiling the kernel.

The interview then covers why select() must repeatedly copy the descriptor set and cannot indicate which socket is ready, leading to extra system calls after waking.

Comparing poll() to select(), the only difference is that poll() uses an array of pollfd structures instead of a bitmap, removing the 1024‑descriptor limit but retaining the same performance drawbacks.

To address these drawbacks, epoll was introduced. Epoll stores the monitored sockets in a kernel‑resident data structure (an event‑poll object) created via epoll_create(), which returns an epoll file descriptor (epfd). The object contains two regions: a list of watched socket descriptors and a ready‑list. The epoll_ctl() function adds, modifies, or removes sockets from the watch list, while epoll_wait() blocks until one or more sockets become ready, then copies the ready events into a user‑provided epoll_event array.

Internally, epoll uses a red‑black tree to store the watched sockets, providing O(log N) lookup for add/remove operations. When a socket receives data, the network hardware writes the packet directly to memory via DMA, triggers a hardware interrupt, and the interrupt handler moves the waiting process from the socket’s wait queue to the runnable queue. The subsequent select() or epoll_wait() call then sees the ready flag and returns the ready socket information.

Finally, the interview notes that epoll_wait() can be made non‑blocking by passing a timeout of 0, causing it to return immediately with the current ready list.

Key takeaways: understand BIO’s blocking nature, the non‑blocking design of NIO with selectors, the kernel‑level behavior of select/poll, and how epoll’s event‑driven architecture and red‑black‑tree storage overcome their predecessors’ limitations.