在netty 4.1中正确释放引用计数的ByteBuf对象

Question

因此，我们目前正在将基于MQTT的消息后端中的Netty3.x升级到Netty4.1。在我们的应用程序中，我们使用自定义MQTT消息解码器和编码器。

对于我们的解码器，我目前使用的是一个ByteToMessageDecoder，如下所示：

public class MqttMessageDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in.readableBytes() < 2) {
            return;
        }

        .....
        .....
        .....

        byte[] data = new byte[msglength];
        in.resetReaderIndex();
        in.readBytes(data);
        MessageInputStream mis = new MessageInputStream(
                new ByteArrayInputStream(data));
        Message msg = mis.readMessage();
        out.add(msg);
        ReferenceCountUtil.release(in);
    }
}

其中消息是我们的自定义对象，它被传递到下一个ChannelHandler的ChannelRead()。正如您所看到的，当我从传入的Bytebuf对象中创建Message对象时，就完成了中的传入的Bytebuf对象。那么，既然Bytebuf在netty中是引用计数的，那么我需要在这里通过调用referenceCountutil.release(in)来释放in对象是正确的吗？理想情况下，根据医生的说法，这似乎是正确的。然而，当我这样做的时候，我似乎面临着例外：

Wed May 24 io.netty.channel.DefaultChannelPipeline:? WARN netty-workers-7 An exceptionCaught() event was fired, and it reached at the tail of the pipeline. It usually means the last handler in the pipeline did not handle the exception.
io.netty.channel.ChannelPipelineException: com.bsb.hike.mqtt.MqttMessageDecoder.handlerRemoved() has thrown an exception.
    at io.netty.channel.DefaultChannelPipeline.callHandlerRemoved0(DefaultChannelPipeline.java:631) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.channel.DefaultChannelPipeline.destroyDown(DefaultChannelPipeline.java:867) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.channel.DefaultChannelPipeline.access$300(DefaultChannelPipeline.java:45) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.channel.DefaultChannelPipeline$9.run(DefaultChannelPipeline.java:874) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:339) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:374) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:742) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    at java.lang.Thread.run(Thread.java:745) [na:1.8.0_72-internal]
Caused by: io.netty.util.IllegalReferenceCountException: refCnt: 0, decrement: 1
    at io.netty.buffer.AbstractReferenceCountedByteBuf.release(AbstractReferenceCountedByteBuf.java:111) ~[netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.handler.codec.ByteToMessageDecoder.handlerRemoved(ByteToMessageDecoder.java:217) ~[netty-all-4.1.0.Final.jar:4.1.0.Final]
    at io.netty.channel.DefaultChannelPipeline.callHandlerRemoved0(DefaultChannelPipeline.java:626) [netty-all-4.1.0.Final.jar:4.1.0.Final]
    ... 7 common frames omitted

这告诉我，当子通道关闭时，管道中的所有处理程序都相继移除。当这个解码器处理程序关闭时，我们显式地释放附加到这个解码器的Bytebuf，当调用下面的方法时，它会导致IllegalReferenceCountException异常。

这是AbstractReferenceCountedBytebuf#版本:

@Override
    public boolean release() {
        for (;;) {
            int refCnt = this.refCnt;
            if (refCnt == 0) {
                throw new IllegalReferenceCountException(0, -1);
            }

            if (refCntUpdater.compareAndSet(this, refCnt, refCnt - 1)) {
                if (refCnt == 1) {
                    deallocate();
                    return true;
                }
                return false;
            }
        }
    }

那么，释放bytebuf对象的正确方法是什么，以避免遇到此问题？

new ServerBootstrap().childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)

作为Ferrybig答案的附加项，ByTetomessageDecoder#ChannelRead自行处理传入的Bytebuf的释放。请参见finally块-

@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                ByteBuf data = (ByteBuf) msg;
                first = cumulation == null;
                if (first) {
                    cumulation = data;
                } else {
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
                }
                callDecode(ctx, cumulation, out);
            } catch (DecoderException e) {
                throw e;
            } catch (Throwable t) {
                throw new DecoderException(t);
            } finally {
                if (cumulation != null && !cumulation.isReadable()) {
                    numReads = 0;
                    cumulation.release();
                    cumulation = null;
                } else if (++ numReads >= discardAfterReads) {
                    // We did enough reads already try to discard some bytes so we not risk to see a OOME.
                    // See https://github.com/netty/netty/issues/4275
                    numReads = 0;
                    discardSomeReadBytes();
                }

                int size = out.size();
                decodeWasNull = !out.insertSinceRecycled();
                fireChannelRead(ctx, out, size);
                out.recycle();
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }

如果入站的bytebuf被传输到管道中的下一个通道处理程序，则此bytebuf的引用计数通过bytebuf#retain而增加，因此，如果解码器之后的下一个处理程序是业务处理程序（通常是这样），则需要释放该bytebuf对象，以避免任何内存泄漏。这里的文档中也提到了这一点。

Answer 1

并不是所有的处理程序都要求销毁bytebuf中传递的内容。ByTetomessageDecoder就是其中之一。

这是因为该处理程序收集多个传入字节，并将它们作为1个连续的字节流公开给您的应用程序，以便于编码，并且不需要自己处理这些块

请记住，您仍然需要通过使用readbytes或readslice手动释放您创建的任何bytebufs，正如Javadoc所述。