Netty源码阅读之Pipeline中添加以及删除ChannelHandler流程总结

灰太狼 2023-07-22 04:57 10阅读 0赞

## 1.简要介绍 ##

首先，ChannelHandler主要的作用是用来处理inbound或者outbound事件，调用者可以通过ch.pipeline().addLast()来进行添加，我们可以通过一张经典图例来认识一下ChannelHandler、pipeline、以及ChannelHandlerContext之间的关系:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbGlzaGFkYWE_size_16_color_FFFFFF_t_70][]

通过上图，我们知道，Channel以及pipeline之间是一对一的关系，而每一个pipeline中都存在一个ChannelHandler的链路，而每一个ChannelHandler中都会有一个ChannelHandlerContext的引用。

## 2.添加流程 ##

进入io.netty.channel.DefaultChannelPipeline这个类中查看addLast()这个方法:

public final ChannelPipeline addLast(EventExecutorGroup executor, ChannelHandler... handlers) {
            if (handlers == null) {
                throw new NullPointerException("handlers");
            }
    
            for (ChannelHandler h: handlers) {
                if (h == null) {
                    break;
                }
                addLast(executor, null, h);
            }
    
            return this;
        }

很明显，我们可以直接创建多个handler，假如传入的handler为null，那么直接结束。

继续往下查看同名方法：

public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
            final AbstractChannelHandlerContext newCtx;
            synchronized (this) {
                checkMultiplicity(handler);
    
                newCtx = newContext(group, filterName(name, handler), handler);
    
                addLast0(newCtx);
    
                
                if (!registered) {
                    newCtx.setAddPending();
                    callHandlerCallbackLater(newCtx, true);
                    return this;
                }
    
                EventExecutor executor = newCtx.executor();
                if (!executor.inEventLoop()) {
                    newCtx.setAddPending();
                    executor.execute(new Runnable() {
                        @Override
                        public void run() {
                            callHandlerAdded0(newCtx);
                        }
                    });
                    return this;
                }
            }
            callHandlerAdded0(newCtx);
            return this;
        }

对照代码，我们可以很容易总结出添加的流程：

step1：如果这个handler是可以共享的或者没有被其他的pipeline使用，那么就能够添加成功反之，则会抛出"xxx is not a @Sharable handler, so can't be added or removed multiple times."异常。

step2：创建节点并添加节点至链表，通过filterName()函数的逻辑，我们可以知道：handler是不允许重名的，如果没有名称会创建一个默认的名称。

step3：假如这个channel还没有注册到eventoop，那么一直等待，知道这个channel注册到eventLoop上；随后，

需要判断当前线程是否在事件循环线程中，为了保证一个Channel上的事件处理的线程安全，要把所有的IO事件等使用IO线程来处理，就需要判断当前线程是否是eventLoop线程，如果是则可以直接执行，否则需要提交给eventLoop线程去执行。

step4：调用callHandlerAdded0()方法，添加channel，这里也是采用了一个比较有趣的处理方式:

final void setAddComplete() {
            for (;;) {
                int oldState = handlerState;
                // Ensure we never update when the handlerState is REMOVE_COMPLETE already.
                // oldState is usually ADD_PENDING but can also be REMOVE_COMPLETE when an EventExecutor is used that is not
                // exposing ordering guarantees.
                if (oldState == REMOVE_COMPLETE || HANDLER_STATE_UPDATER.compareAndSet(this, oldState, ADD_COMPLETE)) {
                    return;
                }
            }
        }

采用CAS+自旋的操作来进行状态的标记，并且一旦添加的过程中抛出异常，一定要将当前的handler删除掉。

step5：返回ChannelPipeline对象。

## 3. 删除流程 ##

private AbstractChannelHandlerContext remove(final AbstractChannelHandlerContext ctx) {
            assert ctx != head && ctx != tail;
    
            synchronized (this) {
                remove0(ctx);
                
                if (!registered) {
                    callHandlerCallbackLater(ctx, false);
                    return ctx;
                }
    
                EventExecutor executor = ctx.executor();
                if (!executor.inEventLoop()) {
                    executor.execute(new Runnable() {
                        @Override
                        public void run() {
                            callHandlerRemoved0(ctx);
                        }
                    });
                    return ctx;
                }
            }
            callHandlerRemoved0(ctx);
            return ctx;
        }

删除流程类似上述的添加流程，主要分为3步:

step1：调用remove0()函数进行链表节点()的删除,通过上一节([https://lusaijie.blog.csdn.net/article/details/105184344][https_lusaijie.blog.csdn.net_article_details_105184344])，我们知道：ChannelHandlerContext是一个双向循环链表的数据结构，这里将前置节点指向当前节点的前一个节点，并将后置节点指向当前节点的前置节点即可完成节点的删除操作，相信有数据结构基础的读者都能够很快理解。

step2：有代码的对称性，我们可以同样明白如果当前channel没有注册上eventLoop，那么将会等待chennel注册上eventloop，一旦注册上，调用ChannelHandler.handlerRemoved(...)函数进行处理，这里亦需要判断当前线程是否在事件循环线程中，并进行类似的处理。

step3：回调删除Handler事件，标注REMOVE\_COMPLETE状态，然而这里并没有进行自旋的操作，聪明的读者知道这是什么原因吗?

## 4.总结: ##

以上就是对添加以及删除ChannelHandler流程的简单探讨，如有错误，欢迎指正！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbGlzaGFkYWE_size_16_color_FFFFFF_t_70]: /images/20230528/e23c8e436c7a4131986e815d794e92c1.png
[https_lusaijie.blog.csdn.net_article_details_105184344]: https://lusaijie.blog.csdn.net/article/details/105184344