Java中的NIO详解Day06-Selector

快来打我* 2023-03-01 13:57 48阅读 0赞

### Selector ###

*  基本概念
 *  Selector的创建
 *  Selector注册通道
 *  SelectionKey
 *   *   *  interest集合
         *  ready集合
         *  Channel和Selector
         *  附加的对象
 *  Selector选择通道
 *  SelectedKeys
 *  wakeup()
 *  close()
 *  Selector示例

# 基本概念 #

*  选择器**Selector:**
    
     *  Java NIO中能够检测一个或者多个NIO通道,并且能够获取到通道是否为诸如读写事件做好准备的组件
     *  一个单独的线程可以管理多个Channel,从而管理多个网络连接
 *  **使用单个线程来处理多个Channel的优点:**
    
     *  只需要更少的线程来处理通道
        
         *  事实上,可以只用一个线程处理所有的通道
         *  对于操作系统来说,线程之间上下文切换的开销很大,而且每个线程之间都要占用一些内存资源
         *  因此,使用的线程越少越好

# Selector的创建 #

*  通过调用**Selector.open()** 方法创建一个**Selector:**

Selector selector = Selector.open();

# Selector注册通道 #

*  为了将**Channel**和**Selector**配合使用,必须将**channel**注册到**selector**上
 *  通过**SelectorChannel.register()** 方法来实现向**Selector**中注册通道:

channel.configureBlocking(false);
    SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

*  **Channel**必须处于非阻塞模式下,才能与**Selector**一起使用
 *  因为**FileChannel**不能切换到非阻塞模式,所以不能将**FileChannel**与**Selector**一起使用.而套接字通道都可以
 *  **register的第二个参数:**
    
     *  是一个**interest**集合
     *  在通过**Selector**监听**Channel**时对什么事件感兴趣
 *  **Selector可以监听四种不同的类型:** 通道触发了一个事件意味着该事件已经就绪
    
     *  **Connect:** 连接就绪. 某个**channel**成功连接到另一个服务器
     *  **Accept:** 接收就绪. 一个**server socket channe**l准备好接收新进入的连接
     *  **Read:** 读就绪. 一个有数据可读的通道
     *  **Write:** 写就绪. 等待写数据的通道
 *  这四种事件使用**SelectionKey**的四个常量来表示:
    
     *  **SelectionKey.OP\_CONNECT**
     *  **SelectionKey.OP\_ACCEPT**
     *  **SelectionKey.OP\_READ**
     *  **SelectionKey.OP\_WRITE**
 *  如果**Selector**不止对一种事件感兴趣,可以使用**位或**操作符将常量连接起来:

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE

# SelectionKey #

*  当向**Selector**注册**Channel**时 **,register()** 方法会返回一个**SelectionKey**对象,这个对象中包含了**Selector**感 兴趣的属性:
    
     *  **interest集合**
     *  **ready集合**
     *  **Channel**
     *  **Selector**
     *  **附加的对象**

### interest集合 ###

*  **interest集合:** Selector感兴趣的事件集合. 可以通过SelectionKey读写interest集合

int interestSet = selectionKey.interestOps();
    
    boolean isInterestedInAccept = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT;
    boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
    boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;
    boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;

*  使用 **“位于&”** 操作**interest**集合与给定的**SelectionKey**常量,可以确定某个确定的事件是否在**interest**集合中

### ready集合 ###

*  **ready**集合是通道已经准备就绪操作的集合.在一次选择**Selection**之后,会首先访问这个**ready**集合
 *  访问**ready**集合:

int readySet = selectionKey.readyOps();

*  可以使用 **“位或&”** 操作**ready**集合与给定的**SelectionKey**常量,可以确定**Channel**中什么事件或者操作已经就绪
 *  也可以使用**SelectionKey**中的方法来检测**Channel**中什么事件或者操作已经就绪:

selectionKey.isAcceptable();
    selectionKey.isConnectable();
    selectionKey.isReadable();
    selectionKey.isWritable();

### Channel和Selector ###

*  根据**SelectionKey**访问**Channel**和**Selector:**

Channel channel = selectionKey.channel();
    Selector selector = selectionKey.selector();

### 附加的对象 ###

*  为了更加方便地识别某个给定的通道,可以将一个对象或者更多信息附加到**SelectionKey**上
    
     *  可以附加一个与通道一起使用的**Buffer**或者是包含聚集数据的某个对象:
    
        selectionKey.attach(theObject);
        Object theObject = selectionKey.attachment();
    
     *  可以在用**register()** 方法向**Selector**注册**Channel**时附加对象:
    
        SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

# Selector选择通道 #

*  如果向**Selector**注册了一个或多个通道,就可以调用几个重载的**select()** 方法
    
     *  **select()** 方法返回所感兴趣事件已经准备就绪的通道:
        
         *  **连接**
         *  **接受**
         *  **读**
         *  **写**
 *  **select()** 方法:

/* * select()阻塞到至少有一个通道在注册的事件上就绪 * * @return int 表示有多少个通道已经就绪 或者是 从上次调用select()方法后有多少通道变成就绪状态 */
     int select();
    
    /* * select(long timeout)阻塞到至少有一个通道在注册的事件上就绪,最长会阻塞timeout毫秒 * * @param timeout 最长会阻塞timeout毫秒 * @return int 表示有多少个通道已经就绪 或者是 从上次调用select(long timeout)方法后有多少通道变成就绪状态 */
     int select(long timeout);
    
    /* * selectNow()不会阻塞,不管什么通道就绪都立刻返回 * * @return int 此方法执行非阻塞的选择操作,从前一次选择操作后,没有通道变成可选择的,直接返回0 */
     int selectNow();

# SelectedKeys #

*  如果调用了**select()** 方法,并且返回值表明有一个或更多个通道就绪了.然后可以通过调用**selector**的**selectedKeys()** 方法,访问 **“已选择键集selected key set”** 中的就绪通道

Set selectedKeys = selector.selectedKeys();

*  当向**Selector**注册**Channel**时 **,Channel.register()** 方法会返回一个**SelectionKey**对象:
    
     *  **SelectionKey**对象代表了注册到该**Selector**的通道
     *  可以通过**SelectionKey**的**selectedKeySet()** 方法访问这些对象
 *  **可以通过遍历这个已选择的键集合来访问就绪的通道:**

Set selectedKeys = selector.selectedKeys();
    Iterator keyIterator = selectedKeys.iterator();
    while (keyIterator.hasNext()) { 
    	SelectionKey key = keyIterator.next();
    	if (key.isAcceptable()) { 
    		// a connection was acceptable by a ServerSocketChannel
    	}
    	if (key.isConnectable()) { 
    		// a connection was established with a remote server
    	}
    	if (key.isReadable()) { 
    		// a channel is ready for reading
    	}
    	if (key.isWritable()) { 
    		// a channel is ready for writing
    	}
    	keyIterator.remove();
    }

*  循环遍历已选择键集中的每个键,并检测各个键所对应的通道的就绪事件
 *  每次迭代末尾调用**keyIterator.remove():**
    
     *  **Selector**本身不会从已选择键集中移除**SelectionKey**实例
     *  必须在处理完通道时自己移除
     *  下次该通道变成就绪时 **,Selector**会再次将**SelectionKey**实例放入已选择键集中
 *  **SelectionKey.channel()** 方法返回的通道需要转型成为需要处理的类型: 比如**ServerSocketChannel**或者**SocketChannel**等

# wakeup() #

*  某个线程调用**select()** 方法后阻塞,即使没有通道已经就绪,也可以从**select()** 方法返回:
    
     *  只要让其余线程在第一个线程调用**select()** 方法的对象上调用**Selector.wakeup()** 方法
     *  阻塞在**select()** 方法上的线程会立即返回
 *  如果有其余线程调用了**wakeup()** 方法,但是当前没有线程阻塞在**select()** 方法上,下一个调用**select()** 方法的线程会立即返回

# close() #

*  使用完毕**Selector**之后调用**close()** 方法会关闭该**Selector.** 并且注册到该**Selector**上的所有**SelectionKey**实例无效
 *  **Channel**本身并不会关闭

# Selector示例 #

*  打开一个**Selector**
 *  注册一个初始化完成的通道到这个**Selector**上
 *  持续监控这个**Selector**的四种事件:接受,连接,读,写.是否就绪

Selector selector = Selector.open();
    channel.configureBlocking(false);
    SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
    while (true) { 
    	int readyChannels = selector.select();
    	if (readyChannels == 0) { 
    		continue;
    	}
    	Set selectedKeys = selector.selectedKeys();
    	Iterator keyIterator = selectedKeys.iterator();
    	while (keyIterator.hasNext()) { 
    		SelectionKey key = keyIterator.next();
    		if (key.isAcceptable()) { 
    			// 一个连接被ServerSocketChannel接受
    			...
    		}
    		if (key.isConnectable()) { 
    			// 一个连接被远程服务发布
    			...
    		}
    		if (key.isReadable()) { 
    			// 一个准备去读的channel
    			...
    		}
    		if (key.isWritable()) { 
    			// 一个准备去写的channel
    		}
    		keyIterator.remove();
    	}
    }