nio框架中的多个Selector结构

核心提示： 加入的操作是递增一个整型变量并且模数组大小后对应的NioProcessor注册到session里：privateIoProcessor<T>nextProcessor(){checkDisposal();returnpool[Math.abs(processorDistributor

加入的操作是递增一个整型变量并且模数组大小后对应的NioProcessor注册到session里：

　　　　private　IoProcessor<T>　nextProcessor()　{
　　　　　　　　checkDisposal();
　　　　　　　　return　pool[Math.abs(processorDistributor.getAndIncrement())　%　pool.length];
　　　　}
　　　　if　(p　==　null)　{
　　　　　　　　　　　　p　=　nextProcessor();
　　　　　　　　　　　　IoProcessor<T>　oldp　=
　　　　　　　　　　　　　　　　(IoProcessor<T>)　session.setAttributeIfAbsent(PROCESSOR,　p);
　　　　　　　　　　　　if　(oldp　!=　null)　{
　　　　　　　　　　　　　　　　p　=　oldp;
　　　　　　　　　　　　}
　　　　}

这样一来，每个连接都关联一个NioProcessor，也就是关联一个Selector对象，避免了所有连接共用一个Selector负载过高导致 server响应变慢的后果。但是注意到NioSocketAcceptor也有一个Selector，这个Selector用来干什么的呢？那就是集中处理OP_ACCEPT事件的Selector，主要用于连接的接入，不跟处理读写事件的Selector混在一起，因此Mina的默认open的 Selector是cpu+2个。

看完mina2.0之后，我们来看看Grizzly2.0是怎么处理的，Grizzly还是比较保守，它默认就是启动两个Selector，其中一个专门负责accept，另一个负责连接的IO读写事件的管理。Grizzly 2.0中Selector的管理是通过SelectorRunner类，这个类封装了Selector对象以及核心的分发注册逻辑，你可以将他理解成 Mina中的NioProcessor，核心的代码如下：

protected　boolean　doSelect()　{
　　　　　　　　selectorHandler　=　transport.getSelectorHandler();
　　　　　　　　selectionKeyHandler　=　transport.getSelectionKeyHandler();
　　　　　　　　strategy　=　transport.getStrategy();
　　　　　　　　
　　　　　　　　try　{
　　　　　　　　　　　　if　(isResume)　{
　　　　　　　　　　　　　　　　//　If　resume　SelectorRunner　-　finish　postponed　keys
　　　　　　　　　　　　　　　　isResume　=　false;
　　　　　　　　　　　　　　　　if　(keyReadyOps　!=　0)　{
　　　　　　　　　　　　　　　　　　　　if　(!iterateKeyEvents())　return　false;
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　if　(!iterateKeys())　return　false;
　　　　　　　　　　　　}
　　　　　　　　　　　　lastSelectedKeysCount　=　0;
　　　　　　　　　　　　
　　　　　　　　　　　　selectorHandler.preSelect(this);
　　　　　　　　　　　　
　　　　　　　　　　　　readyKeys　=　selectorHandler.select(this);
　　　　　　　　　　　　if　(stateHolder.getState(false)　==　State.STOPPING)　return　false;
　　　　　　　　　　　　
　　　　　　　　　　　　lastSelectedKeysCount　=　readyKeys.size();
　　　　　　　　　　　　
　　　　　　　　　　　　if　(lastSelectedKeysCount　!=　0)　{
　　　　　　　　　　　　　　　　iterator　=　readyKeys.iterator();
　　　　　　　　　　　　　　　　if　(!iterateKeys())　return　false;
　　　　　　　　　　　　}
　　　　　　　　　　　　selectorHandler.postSelect(this);
　　　　　　　　}　catch　(ClosedSelectorException　e)　{
　　　　　　　　　　　　notifyConnectionException(key,
　　　　　　　　　　　　　　　　　　　　"Selector　was　unexpectedly　closed",　e,
　　　　　　　　　　　　　　　　　　　　Severity.TRANSPORT,　Level.SEVERE,　Level.FINE);
　　　　　　　　}　catch　(Exception　e)　{
　　　　　　　　　　　　notifyConnectionException(key,
　　　　　　　　　　　　　　　　　　　　"doSelect　exception",　e,
　　　　　　　　　　　　　　　　　　　　Severity.UNKNOWN,　Level.SEVERE,　Level.FINE);
　　　　　　　　}　catch　(Throwable　t)　{
　　　　　　　　　　　　logger.log(Level.SEVERE,"doSelect　exception",　t);
　　　　　　　　　　　　transport.notifyException(Severity.FATAL,　t);
　　　　　　　　}
　　　　　　　　return　true;
　　　　}