Netty源码分析（一）--- 核心组件NioEventLoopGroup和NioEventLoop的初始化

一、NioEventLoopGroup和NioEventLoop的UML类图

二、NioEventLoopGroup初始化流程

1. 从new一个NioEventLoopGroup开始

   //一、NioEventLoopGroup的构造器
   //1.传入线程数
   public NioEventLoopGroup(int nThreads) {
   	//新增传入为null的执行器
       this(nThreads, (Executor) null);
   }
   //2.构造器
   public NioEventLoopGroup(int nThreads, Executor executor) {
   	//新增传入java底层的selector提供器
       this(nThreads, executor, SelectorProvider.provider());
   }
   //3.构造器
   public NioEventLoopGroup(int nThreads, Executor executor, 
   						final SelectorProvider selectorProvider) {
   	//新增传入默认选择器策略工厂
       this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
   }
   //4.构造器
   public NioEventLoopGroup(int nThreads, Executor executor, 
   						final SelectorProvider selectorProvider,
                           final SelectStrategyFactory selectStrategyFactory) {
       //新增传入执行器拒绝策略
       super(nThreads, executor, selectorProvider, selectStrategyFactory, 
      		RejectedExecutionHandlers.reject());
   }
   
   //二、NioEventLoopGroup的父类MultithreadEventLoopGroup的构造器
   //1.将selector提供器、选择器策略工厂和执行器拒绝策略 包装成可变参数
   protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
   	/**
   		DEFAULT_EVENT_LOOP_THREADS 默认线程数在类加载的时候初始化静态代码块设置为CPU核心数*2
   	    private static final int DEFAULT_EVENT_LOOP_THREADS;
   	    static {
   	        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
   	                "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
   	
   	        if (logger.isDebugEnabled()) {
   	            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
   	        }
   	    }
       **/
       super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
   }
   
   //三、MultithreadEventLoopGroup的父类MultithreadEventExecutorGroup的构造器
   //1.构造器
   protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
   	//新增传入 事件执行选择器（新的连接进来，选择不同的NioEventLoop）
       this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
   }
   //2.构造器
   protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                           EventExecutorChooserFactory chooserFactory, Object... args) {
       if (nThreads <= 0) {
           throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
       }
   
       if (executor == null) {
       	//newDefaultThreadFactory()创建能定义线程名的线程工厂， 它有个newThread方法可以创建FastThreadLocalThread
       	//并创建ThreadPerTaskExecutor执行器（被执行的runnable线程会用FastThreadLocalRunnable包装优化，具体https://www.jianshu.com/p/3fc2fbac4bb7） 
           executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
       }
   	//初始化NioEventLoop线程池组
       children = new EventExecutor[nThreads];
   	//循环
       for (int i = 0; i < nThreads; i ++) {
           boolean success = false;
           try {
           	//创建NioEventLoop 详见 三、NioEventLoop的初始化
               children[i] = newChild(executor, args);
               success = true;
           } catch (Exception e) {
               // TODO: Think about if this is a good exception type
               throw new IllegalStateException("failed to create a child event loop", e);
           } finally {
               if (!success) {
                   for (int j = 0; j < i; j ++) {
                       children[j].shutdownGracefully();
                   }
   
                   for (int j = 0; j < i; j ++) {
                       EventExecutor e = children[j];
                       try {
                           while (!e.isTerminated()) {
                               e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                           }
                       } catch (InterruptedException interrupted) {
                           // Let the caller handle the interruption.
                           Thread.currentThread().interrupt();
                           break;
                       }
                   }
               }
           }
       }
   	//初始化NioEventLoop选择器，连接进来选择哪个NioEventLoop，
   	//Netty根据你传入的的线程数做了细节优化，计算机底层&运算比%运算效率高27倍，所以线程数是2的倍数用的是位运算
       chooser = chooserFactory.newChooser(children);
   
       final FutureListener<Object> terminationListener = new FutureListener<Object>() {
           @Override
           public void operationComplete(Future<Object> future) throws Exception {
               if (terminatedChildren.incrementAndGet() == children.length) {
                   terminationFuture.setSuccess(null);
               }
           }
       };
   
       for (EventExecutor e: children) {
           e.terminationFuture().addListener(terminationListener);
       }
   
       Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
       Collections.addAll(childrenSet, children);
       readonlyChildren = Collections.unmodifiableSet(childrenSet);
   }
   

三、NioEventLoop初始化

1. 从NioEventLoopGroup的 children[i] = newChild(executor, args);开始

   //1. 创建NioEventLoop
   //传入执行器， args= selector提供器、selector策略工厂、执行器拒绝策略
   @Override
   protected EventLoop newChild(Executor executor, Object... args) throws Exception {
   	//this=NioEventLoopGroup
       return new NioEventLoop(this, executor, (SelectorProvider) args[0],
           ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
   }
   
   //2. NioEventLoop构造器
   NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
                SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
        
       super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
       if (selectorProvider == null) {
           throw new NullPointerException("selectorProvider");
       }
       if (strategy == null) {
           throw new NullPointerException("selectStrategy");
       }
       provider = selectorProvider;
       
       final SelectorTuple selectorTuple = openSelector();
       selector = selectorTuple.selector;
       unwrappedSelector = selectorTuple.unwrappedSelector;
       selectStrategy = strategy;
   }
   
   //3. NioEventLoop父类SingleThreadEventLoop构造器
   protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor,
                                   boolean addTaskWakesUp, int maxPendingTasks,
                                   RejectedExecutionHandler rejectedExecutionHandler) {
       super(parent, executor, addTaskWakesUp, maxPendingTasks, rejectedExecutionHandler);
       //赋值，创建适合nio的多生产者单消费者的无锁尾部队列（这个Mpsc队列支持并发插入，插入时好像是while循环CAS操作，保证next节点始终是下一个元素）
       tailTasks = newTaskQueue(maxPendingTasks);
   }
   
   //4. SingleThreadEventLoop父类SingleThreadEventExecutor构造器
   protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                       boolean addTaskWakesUp, int maxPendingTasks,
                                       RejectedExecutionHandler rejectedHandler) {
       super(parent);
       //赋值，任务队列初始唤醒状态为false
       this.addTaskWakesUp = addTaskWakesUp;
       //赋值，最大等待任务Integer的MAX
       this.maxPendingTasks = Math.max(16, maxPendingTasks);
       //赋值，执行器
       this.executor = ObjectUtil.checkNotNull(executor, "executor");
       //赋值，任务队列（同tailTasks尾部队列）
       taskQueue = newTaskQueue(this.maxPendingTasks);
       //赋值，执行器拒绝策略
       rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
   }
   
   //5. SingleThreadEventExecutor父类AbstractScheduledEventExecutor构造器
   protected AbstractScheduledEventExecutor(EventExecutorGroup parent) {
       super(parent);
   }
   
   //6. AbstractScheduledEventExecutor父类AbstractEventExecutor构造器
   protected AbstractEventExecutor(EventExecutorGroup parent) {
   	//赋值，将NioEventLoopGroup保存起来
       this.parent = parent;
   }
   
   //7. 再次回到第二步的	final SelectorTuple selectorTuple = openSelector();
   private SelectorTuple openSelector() {
       final Selector unwrappedSelector;
       try {
       	//jdk提供的多路复用器selector
           unwrappedSelector = provider.openSelector();
       } catch (IOException e) {
           throw new ChannelException("failed to open a new selector", e);
       }
   	//是否开启jdk的SelectionKeys的优化，默认false表示开启了
       if (DISABLE_KEYSET_OPTIMIZATION) {
           return new SelectorTuple(unwrappedSelector);
       }
   	//new一个SelectedSelectionKeySet 替换jdk的SelectionKeys
       final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();
   	//反射获取jdk的"sun.nio.ch.SelectorImpl"
       Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {
           @Override
           public Object run() {
               try {
                   return Class.forName(
                           "sun.nio.ch.SelectorImpl",
                           false,
                           PlatformDependent.getSystemClassLoader());
               } catch (Throwable cause) {
                   return cause;
               }
           }
       });
   
       if (!(maybeSelectorImplClass instanceof Class) ||
               // ensure the current selector implementation is what we can instrument.
               !((Class<?>) maybeSelectorImplClass).isAssignableFrom(unwrappedSelector.getClass())) {
           if (maybeSelectorImplClass instanceof Throwable) {
               Throwable t = (Throwable) maybeSelectorImplClass;
               logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, t);
           }
           return new SelectorTuple(unwrappedSelector);
       }
   
       final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;
   
       Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {
           @Override
           public Object run() {
               try {
               	//获取selectedKeys属性字段
                   Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
                   //获取publicSelectedKeys属性字段
                   Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");
   				//反射强吻获取权限
                   Throwable cause = ReflectionUtil.trySetAccessible(selectedKeysField, true);
                   if (cause != null) {
                       return cause;
                   }
                   //反射强吻获取权限
                   cause = ReflectionUtil.trySetAccessible(publicSelectedKeysField, true);
                   if (cause != null) {
                       return cause;
                   }
   				//原生的selector的属性Set<SelectionKey> selectedKeys = new HashSet();集合替换成SelectedSelectionKeySet对象
                   selectedKeysField.set(unwrappedSelector, selectedKeySet);
                   //原生的selector的属性Set<SelectionKey> publicKeys;集合替换成SelectedSelectionKeySet对象
                   publicSelectedKeysField.set(unwrappedSelector, selectedKeySet);
                   return null;
               } catch (NoSuchFieldException e) {
                   return e;
               } catch (IllegalAccessException e) {
                   return e;
               }
           }
       });
   
       if (maybeException instanceof Exception) {
           selectedKeys = null;
           Exception e = (Exception) maybeException;
           logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, e);
           return new SelectorTuple(unwrappedSelector);
       }
       selectedKeys = selectedKeySet;
       logger.trace("instrumented a special java.util.Set into: {}", unwrappedSelector);
   
   	//最终将Selector原生HashSet结构替换成数组结构，因为HashSet底层是HashMap，add元素时候时间复杂度是O(n),而数组则是O(1)
       return new SelectorTuple(unwrappedSelector,
                                new SelectedSelectionKeySetSelector(unwrappedSelector, selectedKeySet));
   }