netty-eventloop

DiscardServer

package io.netty.example.discard;
    
import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
    
/**
 * Discards any incoming data.
 */
public class DiscardServer {
    
    private int port;
    
    public DiscardServer(int port) {
        this.port = port;
    }
    
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap(); // (2)
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class) // (3)
             .childHandler(new ChannelInitializer<SocketChannel>() { // (4)
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ch.pipeline().addLast(new DiscardServerHandler());
                 }
             })
             .option(ChannelOption.SO_BACKLOG, 128)          // (5)
             .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)
    
            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync(); // (7)
    
            // Wait until the server socket is closed.
            // In this example, this does not happen, but you can do that to gracefully
            // shut down your server.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new DiscardServer(port).run();
    }
}

 

构造Bootstrap时，有一个很重要的元素就是eventLoopGroup（分为bossGroup和workerGroup，bossGroup用来accept，workerGroup用来处理socket IO），eventLoopGroup继承了eventExecutorGroup，eventExecutorGroup可以认为是eventExecutor的容器，可以通过next()获取到eventExecutor。由下面的类图可知eventExecutorGroup继承了executorService，其具有executorService的特性，比如执行提交的任务（通过next()委托给具体的eventExecutor）并获得代表任务执行进度的Future、关闭执行器（shutdown）等。

eventLoopGroup在eventExecutorGroup的基础上提供了register方法，即可以将channel注册在eventLoop上（eventLoopGroup的register内部仍然会调用next()，将channel注册到具体的eventLoop上）。所谓注册就是将eventLoop与channel绑定，对于nio来说，一个eventLoop（NioEventLoop）会绑定多个channel（还会将channel注册在与eventLoop绑定的selector上），对于oio来说，一个eventLoop（ThreadPerChannelEventLoop）只能绑定一个channel。

 下面是EventLoop的类图，EventLoop继承了EventLoopGroup，EventLoop额外提供了inEventLoop()方法来判断当前线程是否在EventLoop中。

我们知道ExecutorService屏蔽了任务如何执行的具体机制，但通常Executor都会持有一个线程池来执行任务，并通过一个阻塞队列来缓存待执行的任务，那EventLoopGroup是怎样的呢？

 

这里以Nio为例，serverSocketChannel在accept后会将socketChannel注册在EventLoop上，并在EventLoop上execute完成注册操作

//childGroup即在ServerBootstrap中配置的childGroup(EventLoopGroup)
childGroup.register(child)

 

NioEventLoop的execute方法

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

        boolean inEventLoop = inEventLoop();
        if (inEventLoop) {
            addTask(task);
        } else {
            //startThread()会调用executor的execute方法，这个executor就是一个java.util.concurrent.Executor
            startThread();
            addTask(task);
            if (isShutdown() && removeTask(task)) {
                reject();
            }
        }

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

 

EventLoop的execute最终会调用EventLoop中executor的execute，这个executor是哪儿来的呢？

public class NioEventLoopGroup extends MultithreadEventLoopGroup {
    //......
    
    //threadFactory会被包装为一个executor，
    //该executor的execute方法就是threadFactory.newThread(command).start();
    //threadFactory的newThread一般都会新建thread，因为thread实例只能start一次。
    public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory) {
      this(nThreads, threadFactory, SelectorProvider.provider());
    }
    
    //这里传入的executor就是EventLoop中的executor，
    //nThreads表示EventExecutor（EventLoop）的个数，这些eventExecutor会持有同一个executor，
    //Group会持有这些eventExecutor，即children，但children还未启动。
    //children = new EventExecutor[nThreads];
    //迭代children[i] = newChild(executor, args);
    public NioEventLoopGroup(int nThreads, Executor executor) {
      this(nThreads, executor, SelectorProvider.provider());
    }
    
    //......
}

 

由上分析可知，netty中EventLoop的核心在于executor，executor提供了真正的执行能力（即线程），下面就是NioEventLoop在executor中的执行的任务（这里的run并不是Runnable的run），可以看出，所谓EventLoop就是一个循环器，该循环器不停的在处理channel的IO事件。

protected void run() {
  for (;;) {
    try {
      switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
        case SelectStrategy.CONTINUE:
          continue;
        case SelectStrategy.SELECT:
          select(wakenUp.getAndSet(false));
          if (wakenUp.get()) {
              selector.wakeup();
          }
        default:
          // fallthrough
      }

      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);
    }
    // Always handle shutdown even if the loop processing threw an exception.
    try {
      if (isShuttingDown()) {
        closeAll();
        if (confirmShutdown()) {
          return;
        }
      }
    } catch (Throwable t) {
      handleLoopException(t);
    }
  }
}