Java IO vs NIO — Blocking Streams vs Non-Blocking Channels

Java IO and NIO are two different models for moving bytes.

Classic IO — java.io from JDK 1.0

• Stream-oriented and blocking: one thread sits in read() until bytes arrive
• One thread per connection — caps out around 5,000–10,000 concurrent connections
• Simple to write and reason about
• Use for files, small-scale clients, batch jobs

NIO — java.nio from JDK 1.4 (2002)

• Channel-and-buffer oriented, supports non-blocking mode
• A Selector watches thousands of channels; one thread handles them all
• Maps to OS primitives: epoll on Linux, kqueue on BSD, IOCP on Windows
• Designed to solve the C10K problem — 10,000+ concurrent connections
• Channels are bidirectional; buffers are fixed-size memory regions you flip and drain

Key NIO features beyond selectors

• Direct (off-heap) buffers — zero-copy I/O on hot paths
• Memory-mapped files via FileChannel.map() — process multi-GB files without loading
• Scatter/gather I/O — one read fills multiple buffers (header + body pattern)
• `FileChannel.transferTo()` — kernel-level zero-copy; Kafka uses this for log replay

NIO.2 in Java 7 is what you actually use daily

• Path, Files, Files.readString, Files.lines, Files.walk
• WatchService for filesystem notifications
• Async I/O via AsynchronousFileChannel
• Even classic-IO code should use these instead of the old File API

Who uses NIO at scale

• Netty, Tomcat NIO connector, Jetty, Undertow
• Kafka, Cassandra, Elasticsearch for memory-mapped files
• Any framework handling hundreds of thousands of concurrent connections

The Java 21 virtual-thread shift

• Project Loom introduced virtual threads — blocking code on a virtual thread doesn't hold an OS thread
• You can now write classic IO code that scales to millions of connections
• NIO's concurrency-scaling advantage is largely neutralized for typical web workloads
• NIO still wins for memory-mapped files, zero-copy, and native interop

Recommendation: Use NIO.2 (`Path`, `Files`) for every modern file operation. Reach for raw NIO channels and selectors only when you're building infrastructure (proxy, broker, database engine) or need memory-mapped/zero-copy behavior. For typical server code on Java 21+, just write clear blocking IO on virtual threads — you'll get NIO-level scaling with IO-level simplicity. Pre-Java 21, reach for a framework like Netty rather than writing raw NIO yourself; hand-rolled selector loops are a nightmare to maintain.