NIO 1. 背景 2. Selector源码分析 3. WindowsSelectorImpl
SelectableChannel对象的多路复用器。
可以通过调用Selector.open()方法创建Selector对象。Selector.open()方法会利用系统默认的SelectorProvider创建Selector对象。也可以通过自定义SelectorProvider对象的openSelector方法创建Selector。Selector会一直处于打开状态，直到调用它的close方法。
SelectionKey对象表示每一个注册到Selector的SelectorChannel。每个Selector维护3个集合：
- key集合：表示注册到该Selector的Channel，通过Channel的register方法可以往key集合中添加元素，取消的key在selection操作之间从key集合中移除，key集合不能直接修改，通过keys方法返回。
- selected-key集合：在selection操作中，从所有的key集合中识别出已经ready的key对应的Channel。通过执行set的remove可以移除key或者执行迭代器对象的remove。否则key将不能通过其他方式移除。不可以直接增加到selected-key集合中。
- cancelled-key集合：key已经被取消，但是对应的Channel还没有撤销，这个集合不可以直接访问，这个cancelled-key总是key集合的子集。当key被取消，close对应的Channel或执行它的cancel方法，则添加key到cancelled-key集合中。取消key将导致下一次Selection操作时它的通道被撤销，同时将从所有的Selector的key集合中删除。
备注：新创建的Selector对象，这3个集合都是空集合。
Selection
在每次执行Selection操作时，key可能从selected-key集合中增加或删除，也可能从key集合和cancelled-key集合中删除。通过select()，select(long)，selectNow()方法执行Selection操作，包含3个步骤：
（1）
2. Selector源码分析
2.1 API
public abstract class Selector implements Closeable {
protected Selector() { }
// 创建Selector对象
public static Selector open() throws IOException {
return SelectorProvider.provider().openSelector();
}
// 检测Selector是否打开
public abstract boolean isOpen();
// 返回创建该Selector的Provider
public abstract SelectorProvider provider();
// 返回Key集合，key集合不能被直接修改，只有在被cancel和channel被撤销的时候key才被移除。并且不是线程安全的集合。
public abstract Set<SelectionKey> keys();
// 返回selected-key集合，key可以直接移除，但是不可以直接增加。并且不是线程安全的集合。
public abstract Set<SelectionKey> selectedKeys();
// 选择channel有IO事件的key。
// 该方法是非阻塞的selection操作，如果自上次selection操作之后无channel具有IO事件，该方法会立刻返回零。
// 执行该方法会立刻清除之前执行的wakeup影响。
public abstract int selectNow() throws IOException;
// 阻塞操作，只有在以下的状态变化时：
//（1）至少有一个IO的channel（2）调用selector.wakeup方法（3）当前线程被interrupt（4）timeout时间到(毫秒)
public abstract int select(long timeout)
throws IOException;
// 阻塞操作，返回条件与select(long timeout)类似
public abstract int select() throws IOException;
// 唤醒当前select阻塞的操作：如果另一个线程当前阻塞在select或select(long)方法。
// 如果当前没有select阻塞，则下次执行select或select(long)则直接返回，除非selectNow同时执行；
//之后select和select(long)方法会正常阻塞；
// 如果在select操作之间多次调用wakeup与调用一次效果是一样的
public abstract Selector wakeup();
// 关闭Selector。
// 调用close方法，如果当前阻塞在selection操作，就像调用wakeup方法一样会立刻中断操作
// 与该selector关联的未cancelled的key将失效，它们的channel将撤销，与Selector相关的其他资源将释放。
// 如果Selector已经关闭，执行这个方法将没有影响。
// selector关闭之后，如果执行与selector相关的操作会报ClosedSelectorException
public abstract void close() throws IOException;
}
2.2 类图
2.3 AbstractSelector
AbstractSelector主要实现了Selector的打开关闭的状态维护，支持异步关闭和中断的begin和end方法，cancelledKeys等。
package java.nio.channels.spi;
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.HashSet;
import java.util.Set;
import sun.nio.ch.Interruptible;
import java.util.concurrent.atomic.AtomicBoolean;
// Selector的基本实现。
public abstract class AbstractSelector
extends Selector
{
private AtomicBoolean selectorOpen = new AtomicBoolean(true); // 是否打开
// The provider that created this selector
private final SelectorProvider provider;
protected AbstractSelector(SelectorProvider provider) {
this.provider = provider;
}
// 三大key集合之一cancelledKeys
private final Set<SelectionKey> cancelledKeys = new HashSet<SelectionKey>();
void cancel(SelectionKey k) { // package-private
synchronized (cancelledKeys) {
cancelledKeys.add(k);
}
}
public final void close() throws IOException {
boolean open = selectorOpen.getAndSet(false);
if (!open)
return;
implCloseSelector();// 只有在Selector未关闭的情况下调用，并且只能被调用一次。
}
// 关闭Selector
// 这个方法被close方法调用去执行Selector的关闭操作，只有在Selector未关闭的情况下调用，并且只能被调用一次。具体参考上面close实现
protected abstract void implCloseSelector() throws IOException;
public final boolean isOpen() {
return selectorOpen.get();
}
public final SelectorProvider provider() {
return provider;
}
protected final Set<SelectionKey> cancelledKeys() {
return cancelledKeys;
}
// 为Selector注册Channel，这个方法被AbstractSelectableChannel.register方法调用
protected abstract SelectionKey register(AbstractSelectableChannel ch,
int ops, Object att);
protected final void deregister(AbstractSelectionKey key) {
((AbstractSelectableChannel)key.channel()).removeKey(key);
}
// -- Interruption machinery --
private Interruptible interruptor = null;
// 支持异步关闭和中断的begin和end方法
protected final void begin() {
if (interruptor == null) {
interruptor = new Interruptible() {
public void interrupt(Thread ignore) {
AbstractSelector.this.wakeup();
}};
}
AbstractInterruptibleChannel.blockedOn(interruptor);
Thread me = Thread.currentThread();
if (me.isInterrupted())
interruptor.interrupt(me);
}
protected final void end() {
AbstractInterruptibleChannel.blockedOn(null);
}
}
备注：支持异步关闭和中断的机制，可以参考http://www.cnblogs.com/lujiango/p/8478154.html
2.4 SelectorImpl
package sun.nio.ch;
import java.io.IOException;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.SocketException;
import java.util.*;
import sun.misc.*;
// Selector的基本实现
abstract class SelectorImpl
extends AbstractSelector
{
// 已经准备IO的keys
protected Set<SelectionKey> selectedKeys;
// 注册到该Selector的所有key
protected HashSet<SelectionKey> keys;
// Public views of the key sets
private Set<SelectionKey> publicKeys; // 不可变
private Set<SelectionKey> publicSelectedKeys; // 可删除，不可增加
protected SelectorImpl(SelectorProvider sp) {
super(sp);
keys = new HashSet<SelectionKey>();
selectedKeys = new HashSet<SelectionKey>();
if (Util.atBugLevel("1.4")) {
publicKeys = keys;
publicSelectedKeys = selectedKeys;
} else {
publicKeys = Collections.unmodifiableSet(keys);
publicSelectedKeys = Util.ungrowableSet(selectedKeys);
}
}
public Set<SelectionKey> keys() {
if (!isOpen() && !Util.atBugLevel("1.4"))
throw new ClosedSelectorException();
return publicKeys;
}
public Set<SelectionKey> selectedKeys() {
if (!isOpen() && !Util.atBugLevel("1.4"))
throw new ClosedSelectorException();
return publicSelectedKeys;
}
// 对于Windows系统，需要WindowsSelectorImpl实现doSelect方法
protected abstract int doSelect(long timeout) throws IOException;
private int lockAndDoSelect(long timeout) throws IOException {
synchronized (this) {
if (!isOpen())
throw new ClosedSelectorException();
synchronized (publicKeys) {
synchronized (publicSelectedKeys) {
return doSelect(timeout);
}
}
}
}
// select方法的实现
public int select(long timeout)
throws IOException
{
if (timeout < 0)
throw new IllegalArgumentException("Negative timeout");
return lockAndDoSelect((timeout == 0) ? -1 : timeout);
}
public int select() throws IOException {
return select(0);
}
public int selectNow() throws IOException {
return lockAndDoSelect(0);
}
public void implCloseSelector() throws IOException {
wakeup();
synchronized (this) {
synchronized (publicKeys) {
synchronized (publicSelectedKeys) {
implClose();
}
}
}
}
// 需要WindowsSelectorImpl实现
protected abstract void implClose() throws IOException;
void putEventOps(SelectionKeyImpl sk, int ops) { }
protected final SelectionKey register(AbstractSelectableChannel ch,
int ops,
Object attachment)
{
if (!(ch instanceof SelChImpl))
throw new IllegalSelectorException();
SelectionKeyImpl k = new SelectionKeyImpl((SelChImpl)ch, this);
k.attach(attachment);
synchronized (publicKeys) {
implRegister(k);
}
k.interestOps(ops);
return k;
}
protected abstract void implRegister(SelectionKeyImpl ski);
void processDeregisterQueue() throws IOException {
// Precondition: Synchronized on this, keys, and selectedKeys
Set cks = cancelledKeys();
synchronized (cks) {
if (!cks.isEmpty()) {
Iterator i = cks.iterator();
while (i.hasNext()) {
SelectionKeyImpl ski = (SelectionKeyImpl)i.next();
try {
implDereg(ski);
} catch (SocketException se) {
IOException ioe = new IOException(
"Error deregistering key");
ioe.initCause(se);
throw ioe;
} finally {
i.remove();
}
}
}
}
}
protected abstract void implDereg(SelectionKeyImpl ski) throws IOException;
abstract public Selector wakeup(); // 定义唤醒方法
}
2.5 WindowsSelectorImpl和EPollSelectorImpl
具体会分析windows平台的WindowsSelectorImpl，Linux平台的EPollSelectorImpl暂时不做分析。
3. WindowsSelectorImpl