Netty

Building event-driven network clients and servers with Bootstrap, EventLoopGroup, Channel, Pipeline, handlers, and graceful shutdown.

Historical Netty 3 architecture and why its APIs/classes should not be projected onto modern Netty 4.x designs.

A practical Netty learning roadmap from event loops and pipelines through buffers, codecs, backpressure, and version-pinned source reading.

A durable mental model for Netty server bootstrap, event loops, channel registration, pipelines, and ByteBuf allocation.

The roles of Bootstrap, EventLoopGroup, EventLoop, Channel, Pipeline, Handler, Future, and ByteBuf.

Why Netty uses direct buffers, their I/O advantages and native-memory/reference-counting risks.

Historical source view of how a NioEventLoopGroup creates and manages child event loops.

How Bootstrap/ServerBootstrap accumulate configuration before channel registration and bind/connect.

End-to-end server bind flow: create, initialize, register, bind, activate, and complete the ChannelFuture.

How readiness on a listening channel leads the event loop to accept new sockets.

How every Channel owns a pipeline of handler contexts and how initial handlers are installed.

First server-startup phase: Bootstrap configuration produces a concrete listening-channel instance.

How Netty associates event loops with executors/threads and why event-loop thread ownership matters.

Wrapping an accepted socket as a child Channel with pipeline/configuration and parent relationship.

Dynamic pipeline modification, handler lifecycle callbacks, event-loop serialization, and sharability constraints.

Applying parent options/attributes and installing child-channel initialization logic before registration.

Creation of the event-loop child set and channel-to-event-loop selection in a NioEventLoopGroup.

Selecting a worker event loop and registering the accepted child channel for thread-confined I/O processing.

Assigning the server channel to an event loop and transport selector before binding.

How an active socket channel becomes interested in read readiness and feeds inbound pipeline events.

Asynchronous local-address bind, channel activation, failure handling, and bind future completion.

ServerBootstrap to active listener: channel creation, initialization, event-loop registration, and bind.

Historical source flow from configured channel factory to a server Channel instance before registration.

How an event-loop-owned server channel performs the transport bind and transitions toward active listening state.

Propagation of channel lifecycle and read events through inbound handlers.

Reader/writer indexes, heap/direct buffers, slicing, reference counting, and ownership rules.

Applying options, attributes, and pipeline handlers to a newly created server channel.

Selector waiting, selected-key processing, queued tasks, scheduling, and fairness inside a Netty NIO event loop.

Propagation of writes, flushes, binds, connects, closes, and other outbound operations through handlers toward the transport.

Allocator abstraction for heap/direct, pooled/unpooled buffers and why allocation strategy is configurable.

Assigning a Channel to an EventLoop, registering with selector/transport state, and firing registration events.

How handler failures become exceptionCaught events and why exceptions need explicit logging, cleanup, and connection policy.

Allocator usage, capacity, slicing, copying, reference-count handling, and leak-safe buffer ownership.

Conceptual Channel hierarchy across transport-independent API, abstract channel support, and concrete NIO/native transports.

Pooled ByteBuf allocation, arenas/chunks/suballocation concepts, reuse benefits, and version-sensitive allocator internals.

Per-thread pooled buffer caching as an allocation optimization, with retention and event-loop affinity trade-offs.