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的作用原理，敬请期待！

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