From Java NIO to Netty: A Practical Guide to High‑Performance Network Programming

Netty has become a hot topic for backend developers, and the author offers five Netty books as a giveaway, with the rules listed at the end of the article.

Before diving into Netty, the article reviews traditional blocking I/O programming: each client connection requires a dedicated thread with a while loop, leading to resource exhaustion, high context‑switch overhead, and byte‑stream‑oriented reads.

Java introduced NIO (non‑blocking I/O) in JDK 1.4 to solve three problems: limited thread resources, inefficient thread switching, and byte‑stream‑based reads. NIO uses a Selector to register many channels on a single thread, allowing one loop to monitor thousands of connections.

An analogy compares the I/O model to assigning a teacher to each child who needs to go to the bathroom (one thread per connection) versus a single teacher polling all children periodically (one thread with a selector).

Despite NIO’s advantages, raw JDK NIO code is complex, error‑prone, and suffers from issues such as the epoll empty‑poll bug, missing thread‑model implementations, and difficult custom protocol handling. Therefore, the author strongly advises against building applications directly on JDK NIO.

Netty abstracts JDK NIO, providing an asynchronous event‑driven framework that simplifies server and client development, handles buffer‑oriented reads, offers built‑in codecs, packet framing, exception handling, and a highly optimized reactor thread model.

Sample NIO server code (raw JDK):

/**
 * @author 闪电侠
 */
public class NIOServer {
    public static void main(String[] args) throws IOException {
        Selector serverSelector = Selector.open();
        Selector clientSelector = Selector.open();
        new Thread(() -> {
            try {
                ServerSocketChannel listenerChannel = ServerSocketChannel.open();
                listenerChannel.socket().bind(new InetSocketAddress(8000));
                listenerChannel.configureBlocking(false);
                listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);
                while (true) {
                    if (serverSelector.select(1) > 0) {
                        Set
set = serverSelector.selectedKeys();
                        Iterator
keyIterator = set.iterator();
                        while (keyIterator.hasNext()) {
                            SelectionKey key = keyIterator.next();
                            if (key.isAcceptable()) {
                                try {
                                    SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
                                    clientChannel.configureBlocking(false);
                                    clientChannel.register(clientSelector, SelectionKey.OP_READ);
                                } finally {
                                    keyIterator.remove();
                                }
                            }
                        }
                    }
                }
            } catch (IOException ignored) {}
        }).start();
        new Thread(() -> {
            try {
                while (true) {
                    if (clientSelector.select(1) > 0) {
                        Set
set = clientSelector.selectedKeys();
                        Iterator
keyIterator = set.iterator();
                        while (keyIterator.hasNext()) {
                            SelectionKey key = keyIterator.next();
                            if (key.isReadable()) {
                                try {
                                    SocketChannel clientChannel = (SocketChannel) key.channel();
                                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                                    clientChannel.read(byteBuffer);
                                    byteBuffer.flip();
                                    System.out.println(Charset.defaultCharset().newDecoder().decode(byteBuffer).toString());
                                } finally {
                                    keyIterator.remove();
                                    key.interestOps(SelectionKey.OP_READ);
                                }
                            }
                        }
                    }
                }
            } catch (IOException ignored) {}
        }).start();
    }
}

Using this raw NIO code feels cumbersome, prompting the shift to Netty.

Netty server example:

/**
 * @author 闪电侠
 */
public class NettyServer {
    public static void main(String[] args) {
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        serverBootstrap.group(boss, worker)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer
() {
                    protected void initChannel(NioSocketChannel ch) {
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new SimpleChannelInboundHandler
() {
                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, String msg) {
                                System.out.println(msg);
                            }
                        });
                    }
                })
                .bind(8000);
    }
}

The Netty server achieves the same functionality—starting the server, accepting connections, and printing received messages—with far fewer lines of code.

Key Netty concepts explained:

The boss group accepts new connections (similar to the I/O server’s acceptor).

The worker group handles read/write and business logic.

Netty client example:

/**
 * @author 闪电侠
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        NioEventLoopGroup group = new NioEventLoopGroup();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer
() {
                    @Override
                    protected void initChannel(Channel ch) {
                        ch.pipeline().addLast(new StringEncoder());
                    }
                });
        Channel channel = bootstrap.connect("127.0.0.1", 8000).channel();
        while (true) {
            channel.writeAndFlush(new Date() + ": hello world!");
            Thread.sleep(2000);
        }
    }
}

Running the client prints a timestamped "hello world" message on the server every two seconds, demonstrating Netty’s concise API.

The article then lists numerous reasons to prefer Netty over raw JDK NIO: reduced learning curve, built‑in thread‑model, automatic handling of packet framing, bug fixes (e.g., empty‑poll), performance optimizations, extensive protocol support, active community, and proven reliability in large‑scale RPC and messaging systems.

Finally, the author promotes the book "Learning Netty with Flash Lightning: Practical Chat Application and Core Principles," describing its two parts—an introductory hands‑on chapter and a deep‑dive source‑code analysis—targeting beginners, intermediate users, and developers new to reading open‑source code. The book includes Maven dependencies, step‑by‑step code, and a structured learning path.