Netty源码学习系列之1-netty的串行无锁化

前言

    最近趁着跟老东家提离职之后、到新公司报道之前的这段空闲时期，着力研究了一番netty框架，对其有了一些浅薄的认识，后续的几篇文章会以netty为主，将近期所学记录一二，也争取能帮未对netty有过了解的园友对netty建立一个完整的认识。netty作为一个优秀的网络框架，值得为其花费一番时间。

    netty的内容细究一下也有不少（虽然与Spring这种庞大的框架相比代码量少很多），本文作为netty系列的第一篇，决定先攀登一个高峰：讲一下netty的串行无锁化。这是netty的一个招牌特性，可以说理解了它，就掌握了netty的命门。开始正文之前，需要额外提醒一下，本文虽然是netty系列的第一篇，但是面向的对象是对netty有过一定了解的园友，如果是新人建议从第二篇【EventLoopGroup的初始化】开始看。

一、Talk is cheap，show me your code

    先把netty的示例demo奉上，此处只要服务端构建的代码就可以了。

public class NettyDemo1 {
    // netty服务端的一般性写法
    public static void main(String[] args) {
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(boss, worker).channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 100)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.bind(90).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
}

    从第4行到第18行，都是在进行初始化的属性赋值，第19行bind方法触发真正的串行无锁化处理逻辑。串行无锁化如何理解呢？望文生义即可，通过串行（即顺序执行），来达到即使没有锁也可以线程安全的效果。具体如何做到呢？且往下追踪bind方法。

二、源码追踪

1、initAndRegister方法

    在AbstractBootstrap类中的doBind方法调用了下面的initAndRegister方法（该方法在netty中很重要，现在先记住混个眼熟），前两步虽然也很重要，但跟本文的主题关系不大，下面主要看第3步：

final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            channel = channelFactory.newChannel();// 1、实例化NioServerSocketChannel
            init(channel);// 2、初始化该channel
        } catch (Throwable t) {
            // ...省略异常处理
        }
        ChannelFuture regFuture = config().group().register(channel);// 3、注册channel
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }
        return regFuture;
    }

    第3步中，group()方法返回的是AbstractBootstrap中的group属性，该属性就是上面服务端demo中的boss变量。

2、boss.register(channel)方法

    追踪进入MultithreadEventLoopGroup的register方法：

public ChannelFuture register(Channel channel) {
        return next().register(channel);
    }

    next方法即从EventLoopGroup的EventExecutor数组中轮询取一个EventExecutor实例，即一个NioEventLoop对象，然后再调用NioEventLoop的register方法。

3、NioEventLoop.register(channel)方法

    跟踪到SingleThreadEventLoop的register方法，如下，此处的promise.channel()返回值即之前的NioServerSocketChannel，它的unsafe()方法返回NioMessageUnsafe对象，所以此处最终调用的是NioMessageUnsafe的register方法。

public ChannelFuture register(final ChannelPromise promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        promise.channel().unsafe().register(this, promise);
        return promise;
    }

4、NioMessageUnsafe.register方法

    该方法位于AbstractChannel的内部类AbstractUnsafe中（AbstractUnsafe是NioMessageUnsafe的父类）：

public final void register(EventLoop eventLoop, final ChannelPromise promise) {
           //... 省略异常校验
            AbstractChannel.this.eventLoop = eventLoop;

            if (eventLoop.inEventLoop()) {// 串行无锁化的第一个判断
                register0(promise);
            } else {
                try {
                    eventLoop.execute(new Runnable() {
                        @Override
                        public void run() {
                            register0(promise);
                        }
                    });
                } catch (Throwable t) {
                    //... 省略异常处理
                }
            }
        }

    在eventLoop的父类SingleThreadEventExecutor中有一个成员变量thread，第5行代码用来判断这个thread是不是Thread.currentThread()，如果不是，则进入esle逻辑，执行eventLoop.execute方法。

5、eventLoop.execute方法

    该方法位于SingleThreadEventExecutor中，主要做的事情有三步：1）、inEventLoop()方法判断当前线程是不是eventLoop中记录的线程；2)、addTask将任务放入队列中；3)、startThread()判断是否启动新线程。每步对应的代码在下面已经标出，比较简单。

    执行到execute方法时，有三种情况：1)、eventLoop中记录的线程为null，即刚完成实例化；2)、eventLoop中记录的线程不为null，但不是当前线程；3）、eventLoop中记录的线程不为null，是当前线程（正常不会出现这种情况）。如果是第一种thread=null，则往队列中添加完任务后会进入startThread方法，在startThread方法中判断state属性是不是未启动，如果是则创建一个新的线程并通过cas将state置为已启动；如果是第二种情况thread!=null，往队列中添加任务后也会进入startThread方法，但由于state属性已经是已启动了，所以不会创建新的线程。至此，task中都添加了一个任务，且thread也有值了。

    task中的任务是合适被执行的？且往下看。

public void execute(Runnable task) {
        if (task == null) {
            throw new NullPointerException("task");
        }

        boolean inEventLoop = inEventLoop();
        addTask(task); // 将task任务放入队列中
        if (!inEventLoop) { // 串行无锁化的第二次判断
            startThread(); // 如果需要，会启动一个线程  重要***
            if (isShutdown()) {
                boolean reject = false;
                try {
                    if (removeTask(task)) {
                        reject = true;
                    }
                } catch (UnsupportedOperationException e) {
                }
                if (reject) {
                    reject();
                }
            }
        }

        if (!addTaskWakesUp && wakesUpForTask(task)) {
            wakeup(inEventLoop);
        }
    }

6、doStartThread()方法

    此方法位于SingleThreadEventExecutor类，executor即封装的线程池了，在run方法中完成了对thread的赋值，然后执行了当前类的run方法。

7、SingleThreadEventExecutor.run()方法

    该方法的实现在NioEventLoop中，如下，多出对 runAllTasks()方法进行调用，就是在这个方法中完成的对队列中任务的执行，直接调用的task.run方法，即单线程串行消费队列。

protected void run() {
        for (;;) {
            try {
                try {
                    switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                    case SelectStrategy.CONTINUE:
                        continue;
                    case SelectStrategy.BUSY_WAIT:
                    case SelectStrategy.SELECT:
                        select(wakenUp.getAndSet(false));
                        if (wakenUp.get()) {
                            selector.wakeup();
                        }
                        // fall through
                    default:
                    }
                } catch (IOException e) {
                    // ...异常处理省略
                    continue;
                }

                cancelledKeys = 0;
                needsToSelectAgain = false;
                final int ioRatio = this.ioRatio;
                if (ioRatio == 100) {
                    try {
                        processSelectedKeys();
                    } finally {
                        // Ensure we always run tasks.
                        runAllTasks();
                    }
                } else {
                    final long ioStartTime = System.nanoTime();
                    try {
                        processSelectedKeys();
                    } finally {
                        // Ensure we always run tasks.
                        final long ioTime = System.nanoTime() - ioStartTime;
                        runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                    }
                }
            } catch (Throwable t) {
                handleLoopException(t);
            }
            // ...省略无关代码
        }
    }

三、小结

    上面是过了一遍netty串行无锁化的流程，下面对整个流程做一下总结。

    netty串行无锁化的实现，是借助了SingleThreadEventExecutor中的Thread thread、int state和Queue<Runnable> taskQueue这三个成员变量。state变量用于判断当前EventExecutor是否启动（未启动则通过线程池创建一个启动线程并赋值给thread），thread变量用来判断当前线程是不是启动线程（通过inEventLoop方法实现），taskQueue用于存放待启动线程串行执行的任务。在NioEventLoop的run方法中，每一次循环都遍历一遍taskQueue执行里面的任务。

    可以知道，一个NioEventLoop对应一个串行执行的启动线程，Reactor主线程对应的是boss中的一个NioEventLoop，负责串行执行客户端连接事件，Reactor子线程是有客户端接入事件后由主线程启用的，对应worker中的一个NioEventLoop，负责串行执行客户端读写时间。

    至此，串行无锁化的内容就结束了，后面将从EventLoopGroup的初始化开始，一步步从零开始拆解netty的作用原理，敬请期待！

    原创不易，若有问题，还请批评指正，感谢！