Differences Between BIO, NIO, and AIO in Java Network Programming

Interview Question: Differences between BIO, NIO, AIO

Before discussing BIO, NIO, and AIO, we review the concepts of synchronous vs asynchronous and blocking vs non‑blocking I/O.

Synchronous

Must perform operations one after another; the client waits for the server to process the request before doing anything else.

Official definition: In synchronous I/O, Java handles the read/write itself.

Asynchronous

Requests are triggered by events; the server processes them while the client can continue other work.

Official definition: In asynchronous I/O, Java delegates read/write to the OS, passing buffer address and size; the OS notifies Java upon completion (callback).

Blocking

During an operation (e.g., boiling water) you cannot do anything else; performance and reliability suffer.

Official definition: In blocking I/O, the Java call blocks until the read/write finishes.

Non‑Blocking

You can perform other tasks while waiting; suitable for low‑load, low‑concurrency applications.

Official definition: In non‑blocking I/O, if the operation cannot be performed immediately, the call returns immediately; the selector notifies when the channel is ready, and the operation repeats until complete.

I/O models are typically classified as:

Synchronous blocking BIO

Synchronous non‑blocking NIO

Asynchronous non‑blocking AIO

1. Traditional BIO (synchronous blocking)

Server creates a socket per client connection; each socket is handled by a dedicated thread, preventing the server from accepting new connections while a thread is busy. This leads to a thread‑per‑connection model, causing high CPU usage and possible memory overflow; thread pools can mitigate but not eliminate the issue.

Problem: How to handle high concurrency?

Solution leads to NIO.

2. NIO (synchronous non‑blocking)

Introduced in JDK 1.4, NIO provides channel‑based, buffer‑oriented I/O.

Channel : bidirectional, works with buffers; unlike streams, it can read and write.

Buffer : object that holds data to be read or written.

Selector : allows a single thread to manage multiple channels, reducing thread‑switching overhead.

Server uses a selector to register multiple requests; when the selector detects an I/O event, a thread processes it. This achieves “single‑thread management of multiple connections”. Drawbacks include higher maintenance cost and potential bugs in large projects.

3. AIO (asynchronous non‑blocking)

JDK 1.7 introduced NIO.2 (AIO), an asynchronous non‑blocking model.

Asynchronous I/O is based on events and callbacks: the application call returns immediately, and the OS notifies the thread when the operation completes.

Server handles multiple active requests with a single thread; the OS completes the I/O and then notifies the application to continue processing.

Use case: For low concurrent connections, BIO is simple; for high concurrency, prefer NIO or AIO, or use a mature framework like Netty.

Summary:

BIO – one connection per thread.

NIO – one request per thread.

AIO – one active request per thread.