关键代码：NioEventLoop => **final SelectorTuple selectorTuple = openSelector();**

    1. NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
    2.                  SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
    3.                  EventLoopTaskQueueFactory queueFactory) {
    4.     // parent：this => NioEventLoopGroup
    5.     // selectorProvider：SelectorProvider 默认为 SelectorProvider.provider()，该方法可以打开一个 selector 或者 ServerSocketChannel
    6.     // strategy：selectStrategyFactory  默认选择策略工厂
    7.     // rejectedExecutionHandler：RejectedExecutionHandler 线程拒绝策略，默认为 抛异常
    8.     super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
    9.           rejectedExecutionHandler);
    10.     if (selectorProvider == null) {
    11.         throw new NullPointerException("selectorProvider");
    12.     }
    13.     if (strategy == null) {
    14.         throw new NullPointerException("selectStrategy");
    15.     }
    16.     // provider = SelectorProvider.provider()
    17.     provider = selectorProvider;
    18.     // ★ 开始创建 selector
    19.     // ★ SelectorTuple = [selector = SelectedSelectionKeySetSelector 做了一层包装的 Selector, unwrappedSelector = 替换了 HashSet 的原生 selector]
    20.     final SelectorTuple selectorTuple = openSelector();
    21.     // ★ selector = SelectedSelectionKeySetSelector 做了一层包装的 Selector
    22.     selector = selectorTuple.selector;
    23.     // ★ unwrappedSelector = 替换了 HashSet 的原生 selector
    24.     unwrappedSelector = selectorTuple.unwrappedSelector;
    25.     // selectStrategyFactory  默认选择策略工厂
    26.     selectStrategy = strategy;
    27. }

    利用反射：**sun.nio.ch.SelectorImpl，将 SelectorImpl 中的 HashSet keys，与 Set publicKeys 属性，替换为** Netty 自己实现的 Set（SelectedSelectionKeySet）

    1. private SelectorTuple openSelector() {
    2.         final Selector unwrappedSelector;
    3.         try {
    4.             unwrappedSelector = provider.openSelector();
    5.         } catch (IOException e) {
    6.             throw new ChannelException("failed to open a new selector", e);
    7.         }
    9.         if (DISABLE_KEY_SET_OPTIMIZATION) {
    10.             return new SelectorTuple(unwrappedSelector);
    11.         }
    13.         Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {
    14.             @Override
    15.             public Object run() {
    16.                 try {
    17.                     return Class.forName(
    18.                             "sun.nio.ch.SelectorImpl",
    19.                             false,
    20.                             PlatformDependent.getSystemClassLoader());
    21.                 } catch (Throwable cause) {
    22.                     return cause;
    23.                 }
    24.             }
    25.         });
    27.         if (!(maybeSelectorImplClass instanceof Class) ||
    28.             // isAssignableFrom() 方法是从继承的角度来判断，instanceof 关键字是从实例继承的角度来判断
    29.             // isAssignableFrom() 方法是判断是否是某个类的父类，instanceof 关键字是判断是否是某个类的子类
    30.             // 使用方法：父类.class.isAssignableFrom(子类.class)，子类实例 instanceof 父类类型
    31.             // ensure the current selector implementation is what we can instrument.
    32.             !((Class<?>) maybeSelectorImplClass).isAssignableFrom(unwrappedSelector.getClass())) {
    33.             if (maybeSelectorImplClass instanceof Throwable) {
    34.                 Throwable t = (Throwable) maybeSelectorImplClass;
    35.                 logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, t);
    36.             }
    37.             return new SelectorTuple(unwrappedSelector);
    38.         }
    40.         final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;
    42.         // Netty 自定义的 Set 集合
    43.         final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();
    45.         Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {
    46.             @Override
    47.             public Object run() {
    48.                 try {
    49.                     // selectedKeysField = HashSet<SelectionKey>
    50.                     Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
    51.                     // publicSelectedKeysField = HashSet<SelectionKey>
    52.                     Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");
    54.                     // 版本判断（可忽略）
    55.                     if (PlatformDependent.javaVersion() >= 9 && PlatformDependent.hasUnsafe()) {
    56.                         // Let us try to use sun.misc.Unsafe to replace the SelectionKeySet.
    57.                         // This allows us to also do this in Java9+ without any extra flags.
    58.                         long selectedKeysFieldOffset = PlatformDependent.objectFieldOffset(selectedKeysField);
    59.                         long publicSelectedKeysFieldOffset =
    60.                                 PlatformDependent.objectFieldOffset(publicSelectedKeysField);
    62.                         if (selectedKeysFieldOffset != -1 && publicSelectedKeysFieldOffset != -1) {
    63.                             PlatformDependent.putObject(
    64.                                     unwrappedSelector, selectedKeysFieldOffset, selectedKeySet);
    65.                             PlatformDependent.putObject(
    66.                                     unwrappedSelector, publicSelectedKeysFieldOffset, selectedKeySet);
    67.                             return null;
    68.                         }
    69.                         // We could not retrieve the offset, lets try reflection as last-resort.
    70.                     }
    72.                     // 反射设置可对私有属性赋值
    73.                     Throwable cause = ReflectionUtil.trySetAccessible(selectedKeysField, true);
    74.                     if (cause != null) {
    75.                         return cause;
    76.                     }
    77.                     // 反射设置可对私有属性赋值
    78.                     cause = ReflectionUtil.trySetAccessible(publicSelectedKeysField, true);
    79.                     if (cause != null) {
    80.                         return cause;
    81.                     }
    82.                     // ★★★ 替换了 selectedKeys 原来的 HashSet<SelectionKey> 为 SelectedSelectionKeySet
    83.                     selectedKeysField.set(unwrappedSelector, selectedKeySet);
    84.                     // ★★★ 替换了 publicSelectedKeys 原来的 HashSet<SelectionKey> 为 SelectedSelectionKeySet
    85.                     publicSelectedKeysField.set(unwrappedSelector, selectedKeySet);
    86.                     return null;
    87.                 } catch (NoSuchFieldException e) {
    88.                     return e;
    89.                 } catch (IllegalAccessException e) {
    90.                     return e;
    91.                 }
    92.             }
    93.         });
    95.         // 异常判断（可忽略）
    96.         if (maybeException instanceof Exception) {
    97.             selectedKeys = null;
    98.             Exception e = (Exception) maybeException;
    99.             logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, e);
    100.             return new SelectorTuple(unwrappedSelector);
    101.         }
    103.         // 保存
    104.         selectedKeys = selectedKeySet;
    105.         logger.trace("instrumented a special java.util.Set into: {}", unwrappedSelector);
    106.         // unwrappedSelector 已经替换过底层实现的 selector
    107.         return new SelectorTuple(unwrappedSelector,
    108.                                  // 包装了一下 selector，重写了某些方法
    109.                                  new SelectedSelectionKeySetSelector(unwrappedSelector, selectedKeySet));
    110.     }