java NIO之选择器学习笔记
选择器：
选择器解决的问题：选择器类管理着一个被注册的通道集合的信息和他们的就绪状态。通道和选择器一起被注册，并且使用选择器来更新通道的就绪状态。
可选择通道（SelectableChannel），这个抽象类提供了通道的可选择性所需要的公共方法。FileChannel对象不是可选择的，因为他们没有继承selectableChannel.所有socket通道都是可选择的，包括从管道（Pipe）对象中获取的通道，SelectableChannel可以被注册到selector对象上，一个通道可以被注册到多个选择器上，但是对每个选择器而言只能被注册一次。
选择键（selectionKey）
选择键封装了通道与选择器的注册关系。选择键对象被SelectableChannel.register返回并提供一个表示这种注册关系的标记。通道在被注册到一个选择器上之前，必须先设置为非阻塞模式（通过调用configureBlocking（false））。
调用可选择通道的register（）方法会将他注册到一个选择器上。如果试图注册一个处于阻塞模式的通道，register（）将抛出未检查的IlllegalBlockingModeException异常。此外，通道一旦被注册，就不能回到阻塞状态。试图这样做，则在调用configureBlocking（）方法是抛出IlllegalBlockingModeException异常。并且试图注册一个已经关闭的selectablechannel实例的话，也将抛出异常（losedchannelException）.
键的interest（感兴趣的操作）集合和ready（已经准备好的操作）集合是和特定的通道相关的，每个通道的实现，将定义他自己的选择键类。在register（）方法中可以构造它并且将他传递给所提供的选择器对象。
使用非阻塞I/O编写服务器处理程序，大致步骤为：
1、向selector对象注册感兴趣的事件；
2、从selector中获取感兴趣的事件。
3、根据不同的事件进行相应的处理。
以下代码建立监控三个socket通道的选择器：
Selector selector=Selector.Open（）；
Channel1.register（selector，SelectionKey.OP_READ）；
Channel2.register(selector,Selectionkey.OP_WRITE);
Channel3.register(selector,Selectionkey.OP_WRITE|OP_READ);
readCount =selector.select(10000);
Select方法是阻塞方法，直到过了十秒或者至少有一个通道的I/O操作准备好了。
在SelectionKey中用静态常量定义了四中I/O操作：OP_READ 1、OP_WRITE４、OP_CONNECT 8、OP_ACCEPT 16.任意相加都不相同，可以通过validOps（）方法返回值确定SelectableChannel支持的操作。当通道关闭时，所有相关的建会自动取消，当选择器关闭时，所有被注册到该选择器的通道都将被注销，并且相关的键将立即被无效化。一旦键无效化，调用相关的方法将抛出CancelledKeyException异常。
服务端package it.com.Jerome;
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;
public class SelectorServer {
private Selector selector;
private ServerSocketChannel serverChannel=null;
private int keys =0;
public void start() {
try{
SelectorServer ss=new SelectorServer();
ss.initServer();
ss.listen();
}catch(Exception e){
e.printStackTrace();
}
}
public void initServer() throws IOException {
this.selector=Selector.open();
serverChannel =ServerSocketChannel.open();
serverChannel.socket().bind(new InetSocketAddress("127.0.0.1",8888));
serverChannel.configureBlocking(false);
SelectionKey key = serverChannel.register(this.selector, SelectionKey.OP_ACCEPT);
}
public void listen() throws Exception {
System.out.println("服务已经成功启动！");
while(true){
keys=this.selector.select();
Iterator it=this.selector.selectedKeys().iterator();
if(keys>0){
while(it.hasNext()){
SelectionKey key =(SelectionKey)it.next();
it.remove();
if(key.isAcceptable()){
serverChannel = (ServerSocketChannel)key.channel();
//和客户端链接的通道
SocketChannel channel = serverChannel.accept();
channel.configureBlocking(false);
channel.write(ByteBuffer.wrap(new String("hello client").getBytes()));
channel.register(this.selector, SelectionKey.OP_READ);
}else if(key.isReadable()){
read(key);
}
}
}
else{
System.out.println("selector finished without any keys");
}
}
}
private void read(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel)key.channel();
ByteBuffer buff=ByteBuffer.allocate(1024);
int len=channel.read(buff);
String msg = "服务器收到的信息为："+new String(buff.array(),0,len);
System.out.println(msg);
}
public static void main(String args[]){
new SelectorServer().start();
}
}
客户端：package it.com.Jerome;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class SelectorClient {
private Selector selector;
private ByteBuffer outBuff = ByteBuffer.allocate(1024);
private ByteBuffer inBuff = ByteBuffer.allocate(1024);
private int keys=0;
private SocketChannel channel=null;
public void initClient() throws Exception{
channel = SocketChannel.open();
selector=selector.open();
channel.configureBlocking(false);
channel.connect(new InetSocketAddress("127.0.0.1",8888));
channel.register(this.selector, SelectionKey.OP_CONNECT);
}
public void listen() throws Exception{
while(true){
keys =this.selector.select();
if(keys>0){
Iterator it = this.selector.selectedKeys().iterator();
while(it.hasNext()){
SelectionKey key=(SelectionKey)it.next();
if(key.isConnectable()){
SocketChannel channel=(SocketChannel)key.channel();
if(channel.isConnectionPending()){
channel.finishConnect();
System.out.println("完成链接！");
}
channel.register(this.selector, SelectionKey.OP_WRITE);
}else if(key.isWritable()){
SocketChannel channel=(SocketChannel)key.channel();
outBuff.clear();
System.out.println("客户端正在写数据！");
channel.write(outBuff.wrap("我是clientA".getBytes()));
channel.register(this.selector, SelectionKey.OP_READ);
System.out.println("客户端数据写完成！");
}else if(key.isReadable()){
SocketChannel channel=(SocketChannel)key.channel();
inBuff.clear();
channel.read(inBuff);
System.out.println("==>"+new String(inBuff.array()));
System.out.println("client finish read data!");
}
}
}else{
System.out.println("没有找到感兴趣的事件！");
}
}
}
public static void main(String[] args) {
new SelectorClient().start();
}
public void start() {
try{
initClient();
listen();
}catch(Exception e){
e.printStackTrace();
}
}
}