java nio_selector

概述

多路复用选择器是NIO能够实现非阻塞式通信的核心。从前面可以，即使没有阻塞，客户端和服务器端也无法正常完成通信，需要手动进行阻塞；但是，通过selector，可以通过channel实现非阻塞式通信，无须开启多个线程，单线程就可以处理多个客户端连接请求。

服务器端设置非阻塞即可，客户端不能设置非阻塞，要不然可能连接还未建立客户端就往外写出数据了

作用

针对非阻塞的通道进行事件的选择 （如果是阻塞，没有选择的余地 ；如果设置成非阻塞时，相当于当事件触发时，可以唤醒channel）

selector能够对 ==事件==进行选择，拦截（例如拦截一些只有while(true)，但是没有真正实际意义的请求）；

凡是能够触发服务器的操作， 真正需要服务器进行响应的操作才能够叫做事件。（你比如客户端需要向服务器端发送数据，但是数据还没有准备好之前，这段时间是 空窗期，服务器端等着是浪费资源的）

selector的工作原理

selector用于检查多个channel的状态是否处于可读、可写状态。从而实现单个线程管理多个channel，也就是多个网络连接。

例如，selector上有多个channel，selector依次询问：你好了吗？你可以写了吗？你准备读了吗？（相当于在这里利用selector阻塞了channel，使得channel达到可读可写状态是才真正的唤醒服务器）；

seletor的优势

使用更少的线程来就可以来处理通道了， 相比使用多个线程，避免了线程上下文切换带来的开销。减少了线程数量，减少了开销，但是仍然可以处理多个客户端请求

selector的使用

因为selector可以对channel做出选择，需要将channel（相当于关于客户端的一个连接）注册到选择器上

1、selector创建

Selector open = Selector.open();

2、将一个 非阻塞 的channel注册到selector上，交给selector进行管理
不需要手动阻塞了

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

ps：注册到selector上的必须是非阻塞式channel，所以FileChannel不适用Selector，因为FileChannel不能切换为非阻塞模式，更准确的来说是因为FileChannel没有继承SelectableChannel

SelectableChannel抽象类 有一个 configureBlocking（） 方法用于使通道处于阻塞模式或非阻塞模式

abstract SelectableChannel configureBlocking(boolean block) 

register() 方法的第一个参数是channel注册到哪一个selector进行管理；第二个参数是一个"interest集合"，表示在通过Selector监听Channel时对什么事件感兴趣。

可以监听的不同类型的事件：(事件就是能够触发服务器的工作)

• Connect ——SelectionKey.OP_CONNECT
• Accept ——SelectionKey.OP_ACCEPT
• Write ——SelectionKey.OP_READ
• Read ——SelectionKey.OP_WRITE
  如果你对不止一种事件感兴趣，使用或运算符即可，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

通道选择到了一个事件是指事件已经就绪。例如：一个有数据可读的通道可以说是 “ 读就绪 ”，一个通道准备写数据就叫做 **“写就绪”，**一个Server Socket Channel准备好接收新进入的连接称为 “ 接收就绪 ”，某个Channel成功连接到另一个服务器称为 “ 连接就绪 ”。

就绪状态下的channel就可以真正开始工作了

SelectionKey介绍

将一个channel注册到某一个selector上时会返回一个Selecionkey,表示了一个channel和selector之间的注册关系。（是唯一的）

一个channel是可以被注册到多个Selector上面的

SelectionKey上的方法介绍

key.attachment(); //返回SelectionKey的attachment，attachment可以在注册channel的时候指定附加的信息，比如附加一个对象到这个key上
key.channel(); ——"返回该SelectionKey对应的channel"
key.selector(); —— "返回该SelectionKey对应的Selector"
key.interestOps(); ——"就是返回这个channel在这个selector上注册的兴趣选项"
key.readyOps();  —— "返回在这个channel上已经就绪的IO操作"

判断selector是否对channel上的某件事感兴趣

& 全1为1，有0为0

//获取channel上的兴趣集合
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;

检查通道上的事件是否已经就绪

//创建ready集合的方法，通过判断这个整数可以知道哪些IO就绪了
int readySet = selectionKey.readyOps();

//也可以通过SelectionKey的方法判断和他绑定的channel是否就绪
//检查这些操作是否就绪的方法
boolean key.isReadable();//是否可读，是返回 true,读就绪
boolean isWritable()：//是否可写，是返回 true，写就绪
boolean isConnectable()：//是否可连接，是返回 true，连接就绪
boolean isAcceptable()：//是否可接收，是返回 true，可接受连接就绪

从SelectionKey上获得Channel以及Selector

Channel channel = key.channel();
Selector selector = key.selector();
key.attachment(); //返回一个和这个channel绑定的信息

"例如，注册时，将一个对象或者多个对象附着在SelectionKey上，这样就能方便的识别某个给定的通道。"
"例如，可以附加 与通道一起使用的Buffer，或是包含聚集数据的某个对象。"

"方式一"
key.attach(theObject); //事后附着
Object attachedObj = key.attachment();

"方式二:Channel向selector注册时附着"
SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject)

"这样，在获取到Key之后，就可以从key上方便的取出和这个Channel强相关的对象信息"

从Selector中选择channel

如何从选择器中的多个Key中选择出就绪的key
选择器维护注册过的 通道的集合，并且这种注册关系都被封装在 SelectionKey当中。通过

Selector维护的三种类型SelectionKey集合

• 已注册的键的集合(Registered key set)
  所有与选择器进行关联的通道生成的key的集合。其中的有些键可能已经失效了。
  通过 selector.keys() 方法返回

• 已选择的键的集合(Selected key set)
  调用select()方法然后在调用此方法，可以将已经选择的结果keys值进行返回。通过 selector.selectedKeys() 返回

• 已取消的键的集合(Cancelled key set)
  已注册的键的集合的子集，这个集合包含了 cancel() 方法被调用过的键(这个键已经无效了)。一旦某个键被取消掉，调用和这个键相关的方法就会抛出 CancelledKeyException

select()方法

初始化selector之后，上面提到的三个集合都是空的。上面的三个集合都是空的。通过调用select()方法可以对已经就绪的通道做筛选（筛选过程中可以包含感兴趣的事件）。比如读就绪的通道，那么select()方法会返回所有读已经就绪的通道。

• int select()：阻塞到至少有一个channel注册的事件就绪了，返回值int表示有多少个通道准备就绪

• int select(long timeout)：和select()一样，但最长阻塞时间为timeout毫秒。

• int selectNow()：非阻塞，只要有通道就绪就立刻返回。

select()方法返回的int值表示有多少通道已经就绪,自上次调用select()方法后有多少通道变成就绪状态。之前在select（）调用时进入就绪的通道不会在本次调用中被记入，而在前一次select（）调用进入就绪但现在已经不在处于就绪的通道也不会被记入。 相当于是一个增量的计入

调用select()方法，返回的值不会0时，就可以调用selectedKeys()方法放回已选择键的集合。

Set selectedKeys=selector.selectedKeys(); 

从而可以获得和该Key相关联的Selector以及Channel

int i = selector.select();
Set<Selectedkeys> selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()){
	SelectionKey key = keyIterator.next();
	if(key.isAcceptable()){	
	//接收就绪
	//a connection was accepted by a ServerSocketChannel
	}else if(key.isConnectable()){
	//channel的连接就绪，
	//a connection was established with a remote server.和远端服务器连接已建立
	}else if (key.isReadable()) {
        // a channel is ready for reading
        // 读就绪，已经可以从channel中开始读了
    }else if (key.isWritable()) {
        // a channel is ready for writing
        //写就绪，可以看是写入数据了
    }
}

停止选择的方法

选择器执行选择的过程，系统底层会 依次询问 每个通道是否已经就绪，这个过程可能会造成 调用线程进入阻塞状态,有下面几种方式可以唤醒在select（）方法中阻塞的线程。（select()方法是一个阻塞方法）

• wakeup()方法 ：通过调用Selector对象的wakeup（）方法让处在阻塞状态的select()方法立刻返回
  该方法使得选择器上的第一个还没有返回的选择操作立即返回。如果当前没有进行中的选择操作，那么下一次对select()方法的一次调用将立即返回。

• close()方法 ：直接关闭选择器。 该方法使得任何一个在选择操作中阻塞的线程都被唤醒（类似wakeup（）），同时使得注册到该Selector的所有Channel被注销，所有的键将被取消，但是Channel本身并不会关闭。

服务器端模板代码

服务器端

package cn.ruanwenfu.nio.selector;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class WebServer {
    public static void main(String[] args) {
        try {
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8000));
            ssc.configureBlocking(false);
            Selector selector = Selector.open();
            // 注册 channel，并且指定感兴趣的事件是 Accept
            // ServerSocketChannel最对这个事件感兴趣
            ssc.register(selector, SelectionKey.OP_ACCEPT);
            ByteBuffer readBuff = ByteBuffer.allocate(1024);
            ByteBuffer writeBuff  = ByteBuffer.wrap("receive".getBytes());
            while (true) {
                int nReady = selector.select(); //已就绪Channel数
                Set<SelectionKey> keys = selector.selectedKeys(); //已选择集合
                Iterator<SelectionKey> it = keys.iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    if (key.isAcceptable()) {
                        // 创建新的连接，并且把连接注册到selector上，而且，
                        // 声明这个channel只对读操作感兴趣。
                        //这里不需要从key转换，直接拿ServerSocketChannel即可
                        SocketChannel socketChannel = ssc.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ);
                    }
                    else if (key.isReadable()) {//读就绪
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        readBuff.clear();
                        socketChannel.read(readBuff);
                        System.out.println("received : " + new String(readBuff.array(),0,readBuff.position()));
                        key.interestOps(SelectionKey.OP_WRITE);//读完之后，服务器只会接受来自该Channel的写就绪
                    }
                    else if (key.isWritable()) {
                        writeBuff.rewind();
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        socketChannel.write(writeBuff);
                        key.interestOps(SelectionKey.OP_READ); //写完之后只接受读就绪
                    }
                    it.remove(); //移除selectedKey
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}