Blocking vs Non-Blocking & Asynchronous I/O

In UNIX networking, the journey of an incoming network packet or disk read involves two distinct phases:

• Phase 1: Waiting for Data to be Ready: The kernel waits for packets to arrive from the network card (NIC) or disk controller buffer into kernel space memory.
• Phase 2: Copying Data from Kernel to User Space: The kernel copies the buffered bytes from kernel memory into the application process's user-space buffer.

W. Richard Stevens identified the 5 fundamental I/O models based on how applications interact with these two phases:

1. Synchronous Blocking I/O: The calling thread calls read() and is placed in an uninterruptible sleep state by the OS scheduler until data arrives in kernel space AND is fully copied to user space.
2. Synchronous Non-Blocking I/O: The calling thread sets the socket flag to O_NONBLOCK. If no data is available, read() immediately returns EAGAIN or EWOULDBLOCK. The thread must continuously poll the socket in a busy-wait CPU loop.
3. I/O Multiplexing (select, poll, epoll, kqueue): The thread registers thousands of file descriptors with the kernel. The single thread blocks in epoll_wait(), and the kernel wakes it only when one or more sockets are ready.
4. Signal-Driven I/O (SIGIO): The kernel delivers an asynchronous POSIX signal (SIGIO) when data is ready on a descriptor.
5. Asynchronous I/O (POSIX AIO, Linux io_uring, Windows IOCP): The application submits an I/O request and continues immediately. The kernel handles both Phase 1 and Phase 2 in the background, notifying the application only after data has already been copied into the user-space buffer.