Netty对NIO中Selector的优化

以你之姓@ 2023-01-02 11:26 82阅读 0赞

# Netty对底层Selector的优化 #

netty在创建NioEventLoop时会封装一个JDK底层的Selector属性：

private Selector selector;
    private Selector unwrappedSelector;

## nio中Selector的实现 ##

public abstract class SelectorImpl extends AbstractSelector { 
        protected Set<SelectionKey> selectedKeys = new HashSet();
        protected HashSet<SelectionKey> keys = new HashSet();
        private Set<SelectionKey> publicKeys;
        private Set<SelectionKey> publicSelectedKeys;
    
        protected SelectorImpl(SelectorProvider var1) { 
            super(var1);
            if (Util.atBugLevel("1.4")) { 
                this.publicKeys = this.keys;
                this.publicSelectedKeys = this.selectedKeys;
            } else { 
                this.publicKeys = Collections.unmodifiableSet(this.keys);
                this.publicSelectedKeys = Util.ungrowableSet(this.selectedKeys);
            }
    
        }
        ... ...
    }

属性说明：

*  keys：存放所有注册的SelectionKey。
 *  selectedKeys：存放监听到事件的SelectionKey。
 *  publicKeys：向外暴露所有注册的SelectionKey，不允许修改。
 *  publicSelectedKeys：向外暴露监听到事件的SelectionKey，不允许增加，可以删除。

HashSet的add方法在发生哈希冲突时的时间复杂度是O(n), 为此Netty通过反射机制, 将底层的这个HashSet用数组替换了, 因为向数组中添加数据的时间复杂度是O(1)。

## netty的SelectedSelectionKeySet ##

final class SelectedSelectionKeySet extends AbstractSet<SelectionKey> { 
    
        SelectionKey[] keys;
        int size;
    
        SelectedSelectionKeySet() { 
            keys = new SelectionKey[1024];
        }
    
        @Override
        public boolean add(SelectionKey o) { 
            if (o == null) { 
                return false;
            }
    
            keys[size++] = o;
            if (size == keys.length) { 
                increaseCapacity();
            }
    
            return true;
        }

从这里我们可以发现, 这个Set集合底层使用的是数组, 调用add方法时直接向数组中添加元素就可以, 时间复杂度O(1)。

## netty中对Selector的改进 ##

NioEventLoop的构造方法：

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
                 SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
                 EventLoopTaskQueueFactory queueFactory) { 
        super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
                rejectedExecutionHandler);
        this.provider = ObjectUtil.checkNotNull(selectorProvider, "selectorProvider");
        this.selectStrategy = ObjectUtil.checkNotNull(strategy, "selectStrategy");
        final SelectorTuple selectorTuple = openSelector(); // 创建Selector
        this.selector = selectorTuple.selector;
        this.unwrappedSelector = selectorTuple.unwrappedSelector;
    }

io.netty.channel.nio.NioEventLoop\#openSelector：

private SelectorTuple openSelector() { 
        final Selector unwrappedSelector; // nio原生的Selector
        try { 
            unwrappedSelector = provider.openSelector();
        } catch (IOException e) { 
            throw new ChannelException("failed to open a new selector", e);
        }
    
        final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;
        final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet(); // 基于数组实现的Selector
        ... ...
        Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
        Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");
        ... ...
        selectedKeysField.set(unwrappedSelector, selectedKeySet);
        publicSelectedKeysField.set(unwrappedSelector, selectedKeySet);

通过反射将SelectedSelectionKeySet类替换掉了Selector类中的HashSet。