How does Netty solve the half-packet and sticky-packet problems?

Netty is a high-performance, asynchronous event-driven network application framework that is widely used in various network communication scenarios. In this article, we will analyze in detail how Netty solves the half-packet and sticky packet problems.

1. What are half packs and sticky packs?

1. Half-package problem

The half-packet problem means that a complete application layer message is divided into multiple TCP data packets and sent, and the receiver only receives part of the message in one read operation.

For example, the sender sends a 100-byte message, but due to network reasons, the message is split into two TCP packets, one 60 bytes and the other 40 bytes. The receiver may only receive the first 60 bytes of data in the first read, and the remaining 40 bytes need to be received in subsequent read operations.

2. Sticky bag problem

The packet sticking problem refers to the situation where multiple application layer messages are stuck together during transmission, and the receiving end receives more than one message in a read operation.

For example, the sender sends two messages, each of 50 bytes, but the receiver receives 80 bytes of data in a read operation, which exceeds the content of one message.

3. Causes

There are three main reasons for the half-package and sticky package problems:

• TCP's streaming characteristics: TCP is a byte stream-oriented protocol with no concept of message boundaries. It guarantees the order and reliability of data, but does not guarantee that the data sent each time corresponds to the data received each time.
• Network conditions: Network congestion, delay, jitter and other factors may cause data packets to be split and reassembled.
• Operating system and buffers: The operating system TCP/IP protocol stack and the application's buffer size also affect how data is read.

4. Examples

Suppose the sender sends two messages:

• Message 1: Hello
• Message 2: World

In the case of half packet, the receiving end may receive it like this:

• First read: Hel
• Second read: loWo
• Third read: rld

In the case of sticky packets, the receiving end may receive the following:

• First read: HelloWorld
• Second read: ld

2. Solution

1. Fixed-length decoder

A decoder based on a fixed length means that when sending a message, the length of each message is fixed, and when reading a message, the message is also read using a fixed length, thus solving the half-packet and sticky packet problems.

(1) Implementation

Netty provides the FixedLengthFrameDecoder class to implement this function. The core source code is as follows:

 public class FixedLengthFrameDecoder extends ByteToMessageDecoder { private final int frameLength; public FixedLengthFrameDecoder(int frameLength) { this.frameLength = frameLength; } @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { while (in.readableBytes() >= frameLength) { ByteBuf buf = in.readBytes(frameLength); out.add(buf); } } }

(2) Notes

When using fixed-length frames, pay attention to the following points:

• Fixed length: The message length must be fixed, and the sender needs to ensure that the message length is consistent. If the length exceeds the fixed length, the message will be misplaced when unpacking. If the message is less than the fixed length, padding characters are needed to fill it.
• Padding characters: Select appropriate padding characters (such as spaces) to complete the message length. The receiving end needs to remove these padding characters during processing.

(3) Advantages

• Simple and easy to implement: It is very simple to implement and does not require additional header information or separators.
• High parsing efficiency: Since each message has a fixed length, the receiving end only needs to read according to the fixed length when parsing.

(4) Disadvantages

• Inflexible: The message length is fixed, which may cause wasted space (if the message length is short) or insufficient space (if the message length is long).
• Limited application scenarios: It is suitable for protocols with fixed formats and lengths, but not for scenarios with variable-length messages.

(5) Example

The following example shows how to use fixed-length frames to solve the half-packet sticking problem.

The sender ensures that each message has a fixed length. If the actual message length is insufficient, fill it with a padding character (such as a space).

 public class FixedLengthFrameSender { private static final int FRAME_LENGTH = 10; // 固定消息长度public static void send(Channel channel, String message) { // 确保消息长度不超过固定长度if (message.length() > FRAME_LENGTH) { throw new IllegalArgumentException("Message too long"); } // 使用空格填充消息到固定长度String paddedMessage = String.format("%-" + FRAME_LENGTH + "s", message); // 将消息转换为字节数组并发送ByteBuf buffer = Unpooled.copiedBuffer(paddedMessage.getBytes()); channel.writeAndFlush(buffer); } }

On the receiving end, use the FixedLengthFrameDecoder decoder provided by Netty to process fixed-length messages.

 import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.handler.codec.FixedLengthFrameDecoder; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.socket.SocketChannel; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioServerSocketChannel; public class FixedLengthFrameReceiver { private static final int FRAME_LENGTH = 10; // 固定消息长度public static void main(String[] args) throws Exception { NioEventLoopGroup bossGroup = new NioEventLoopGroup(1); NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline p = ch.pipeline(); // 添加定长帧解码器p.addLast(new FixedLengthFrameDecoder(FRAME_LENGTH)); // 添加自定义处理器p.addLast(new FixedLengthFrameHandler()); } }); // 启动服务器b.bind(8888).sync().channel().closeFuture().sync(); } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static class FixedLengthFrameHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { ByteBuf in = (ByteBuf) msg; byte[] receivedBytes = new byte[in.readableBytes()]; in.readBytes(receivedBytes); String receivedMsg = new String(receivedBytes).trim(); // 去除填充字符System.out.println("Received: " + receivedMsg); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } }

2. Line break based decoder

3. Custom delimiter decoder

Message boundaries are divided based on line break decoders and custom delimiter decoders (such as special characters), thereby solving the problems of half-packet and sticky packet. Users can flexibly determine the delimiter according to their needs.

(1) Implementation

Netty provides the DelimiterBasedFrameDecoder class to implement this function. The core source code is as follows:

 public DelimiterBasedFrameDecoder( int maxFrameLength, boolean stripDelimiter, boolean failFast, ByteBuf... delimiters) { validateMaxFrameLength(maxFrameLength); ObjectUtil.checkNonEmpty(delimiters, "delimiters"); if (isLineBased(delimiters) && !isSubclass()) { lineBasedDecoder = new LineBasedFrameDecoder(maxFrameLength, stripDelimiter, failFast); this.delimiters = null; } else { this.delimiters = new ByteBuf[delimiters.length]; for (int i = 0; i < delimiters.length; i ++) { ByteBuf d = delimiters[i]; validateDelimiter(d); this.delimiters[i] = d.slice(d.readerIndex(), d.readableBytes()); } lineBasedDecoder = null; } this.maxFrameLength = maxFrameLength; this.stripDelimiter = stripDelimiter; this.failFast = failFast; }

(2) Notes

• Delimiter selection: Select a delimiter that will not appear in the message content (such as newline \n or special characters |).
• Message format: The sender adds a delimiter at the end of each message to ensure that the receiver can correctly parse the message boundaries.

(3) Advantages

• High flexibility: Can handle messages of variable length.
• The implementation is relatively simple: just add a specific delimiter at the end of the message, and the receiving end splits the message based on the delimiter.

(4) Disadvantages

• Delimiter conflict: If the message content contains delimiters, parsing errors may occur and the message content needs to be escaped.
• Low parsing efficiency: The entire data stream needs to be scanned to find the separator, which is inefficient.

(5) Example

Below we use an example to show how to use separators to solve the problem of half-package sticking.

The sender ensures that each message ends with a specific delimiter. Common delimiters include newline (\n), specific characters (such as |), etc.

 public class DelimiterBasedFrameSender { private static final String DELIMITER = "\n"; // 分隔符public static void send(Channel channel, String message) { // 在消息末尾添加分隔符String delimitedMessage = message + DELIMITER; // 将消息转换为字节数组并发送ByteBuf buffer = Unpooled.copiedBuffer(delimitedMessage.getBytes()); channel.writeAndFlush(buffer); } }

On the receiving end, use the DelimiterBasedFrameDecoder decoder provided by Netty to process messages ending with a delimiter.

 import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.DelimiterBasedFrameDecoder; import io.netty.handler.codec.string.StringDecoder; public class DelimiterBasedFrameReceiver { private static final String DELIMITER = "\n"; // 分隔符private static final int MAX_FRAME_LENGTH = 1024; // 最大帧长度public static void main(String[] args) throws Exception { NioEventLoopGroup bossGroup = new NioEventLoopGroup(1); NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline p = ch.pipeline(); // 添加分隔符解码器ByteBuf delimiter = Unpooled.copiedBuffer(DELIMITER.getBytes()); p.addLast(new DelimiterBasedFrameDecoder(MAX_FRAME_LENGTH, delimiter)); // 添加字符串解码器p.addLast(new StringDecoder()); // 添加自定义处理器p.addLast(new DelimiterBasedFrameHandler()); } }); // 启动服务器b.bind(8888).sync().channel().closeFuture().sync(); } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static class DelimiterBasedFrameHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { String receivedMsg = (String) msg; System.out.println("Received: " + receivedMsg); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } }

4. Decoder based on length field

A decoder based on the length field refers to adding a length field to the message header to indicate the total length of the message.

(1) Implementation

Netty provides the LengthFieldBasedFrameDecoder class to implement this function. The core source code is as follows:

 public class LengthFieldBasedFrameDecoder extends ByteToMessageDecoder { private final int maxFrameLength; private final int lengthFieldOffset; private final int lengthFieldLength; public LengthFieldBasedFrameDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) { this.maxFrameLength = maxFrameLength; this.lengthFieldOffset = lengthFieldOffset; this.lengthFieldLength = lengthFieldLength; } @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { if (in.readableBytes() < lengthFieldOffset + lengthFieldLength) { return; } in.markReaderIndex(); int length = in.getInt(in.readerIndex() + lengthFieldOffset); if (in.readableBytes() < lengthFieldOffset + lengthFieldLength + length) { in.resetReaderIndex(); return; } in.skipBytes(lengthFieldOffset + lengthFieldLength); ByteBuf frame = in.readBytes(length); out.add(frame); } }

(2) Key points

Length field location: The length field is usually located in the header of the message and is used to indicate the total length of the message.

Decoder parameters:

• maxFrameLength: The maximum length of a message to prevent memory overflow.
• lengthFieldOffset: The offset of the length field in the message.
• lengthFieldLength: The number of bytes in the length field (usually 4 bytes).
• lengthAdjustment: length adjustment value. If the length field does not contain the length of the message header, adjustment is required.
• initialBytesToStrip: The number of bytes to skip after decoding, usually the length of the length field.

(3) Advantages

• High flexibility: supports messages of variable length.
• High parsing efficiency: The complete message can be read directly through the length field without scanning the entire data stream.

(4) Disadvantages

• Complex implementation: A length field needs to be added to the message header, and the receiving end needs to parse the header information.
• Additional overhead: The length field in the message header adds a few extra bytes.

(5) Example

The following example shows how to use the length field to solve the half-packet sticking problem.

The sender ensures that each message contains a length field before sending. The length field is usually placed in the header of the message to indicate the total length of the message.

 import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.Channel; public class LengthFieldBasedFrameSender { public static void send(Channel channel, String message) { // 将消息转换为字节数组byte[] messageBytes = message.getBytes(); int messageLength = messageBytes.length; // 创建一个ByteBuf 来存储长度字段和消息内容ByteBuf buffer = Unpooled.buffer(4 + messageLength); // 写入长度字段（4 字节，表示消息长度） buffer.writeInt(messageLength); // 写入消息内容buffer.writeBytes(messageBytes); // 发送消息channel.writeAndFlush(buffer); } }

On the receiving end, use the LengthFieldBasedFrameDecoder decoder provided by Netty to process messages containing the length field.

 import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.LengthFieldBasedFrameDecoder; import io.netty.handler.codec.string.StringDecoder; public class LengthFieldBasedFrameReceiver { private static final int MAX_FRAME_LENGTH = 1024; // 最大帧长度public static void main(String[] args) throws Exception { NioEventLoopGroup bossGroup = new NioEventLoopGroup(1); NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline p = ch.pipeline(); // 添加长度字段解码器p.addLast(new LengthFieldBasedFrameDecoder( MAX_FRAME_LENGTH, 0, 4, 0, 4)); // 添加字符串解码器p.addLast(new StringDecoder()); // 添加自定义处理器p.addLast(new LengthFieldBasedFrameHandler()); } }); // 启动服务器b.bind(8888).sync().channel().closeFuture().sync(); } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static class LengthFieldBasedFrameHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { String receivedMsg = (String) msg; System.out.println("Received: " + receivedMsg); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } }

5. Custom decoder

If the above Netty solution cannot meet the business needs, Netty also provides an extension point where users can process messages through custom decoders.

(1) Implementation

For example, you can customize the header information to indicate the message length or end mark. The sample code is as follows:

 public class CustomProtocolDecoder extends ByteToMessageDecoder { @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { // 根据自定义协议解析消息if (in.readableBytes() < 4) { return; } in.markReaderIndex(); int length = in.readInt(); if (in.readableBytes() < length) { in.resetReaderIndex(); return; } ByteBuf frame = in.readBytes(length); out.add(frame); } }

(2) Advantages

• Highly flexible: The protocol can be designed according to specific needs to adapt to various complex scenarios.
• Rich in functions: You can add other information (such as checksum, serial number, etc.) to the custom protocol to enhance the functionality and reliability of the protocol.

(3) Disadvantages

• Complex implementation: Designing and implementing custom protocols requires more work.
• High maintenance cost: Custom protocols may require more maintenance and update work.

Summarize

In this article, we analyze the causes of half-packets and sticky packets and five solutions in Netty:

• Fixed length decoder based
• Line break based decoder
• Custom delimiter decoder
• Length field based decoder
• Custom decoder

By studying these contents, we not only mastered the theoretical knowledge of half-packing and sticky packing problems, but also learned the specific implementation of various solutions.