如本章第1节中提到的，Selector类可用于避免使用非阻塞式客户端中很浪费资源的"忙等"方法。例如，考虑一个即时消息服务器。可能有上千个客户端同时连接到了服务器，但在任何时刻都只有非常少量的（甚至可能没有）消息需要读取和分发。这就需要一种方法阻塞等待，直到至少有一个信道可以进行I/O操作，并指出是哪个信道。NIO的选择器就实现了这样的功能。一个Selector实例可以同时检查（如果需要，也可以等待）一组信道的I/O状态。用专业术语来说，选择器就是一个多路开关选择器，因为一个选择器能够管理多个信道上的I/O操作。
要使用选择器，需要创建一个Selector实例（使用静态工厂方法open()）并将其注册（register）到想要监控的信道上（注意，这要通过channel的方法实现，而不是使用selector的方法）。最后，调用选择器的select()方法。该方法会阻塞等待，直到有一个或更多的信道准备好了I/O操作或等待超时。select()方法将返回可进行I/O操作的信道数量。现在，在一个单独的线程中，通过调用select()方法就能检查多个信道是否准备好进行I/O操作。如果经过一段时间后仍然没有信道准备好，select()方法就返回0，并允许程序继续执行其他任务。
下面来看一个例子。假设我们想要使用信道和选择器来实现一个回显服务器，并且不使用多线程和忙等。为了使不同协议都能方便地使用这个基本的服务模式，我们把信道中与具体协议相关的处理各种I/O的操作（接收，读，写）分离了出来。TCPProtocol定义了通用TCPSelectorServer类与特定协议之间的接口，包括三个方法，每个方法代表了一种I/O型式。当有信道准备好I/O操作时，服务器只需要调用相应的方法即可。
TCPProtocol.java
0 import java.nio.channels.SelectionKey;
1 import java.io.IOException;
2
3 public interface TCPProtocol {
4 void handleAccept(SelectionKey key) throws IOException;
5 void handleRead(SelectionKey key) throws IOException;
6 void handleWrite(SelectionKey key) throws IOException;
7 }
TCPProtocol.java
在服务器端创建一个选择器，并将其与每个侦听客户端连接的套接字所对应的ServerSocketChannel注册在一起。然后进行反复循环，调用select()方法，并调用相应的操作器例程对各种类型的I/O操作进行处理。
TCPServerSelector.java
0 import java.io.IOException;
1 import java.net.InetSocketAddress;
2 import java.nio.channels.SelectionKey;
3 import java.nio.channels.Selector;
4 import java.nio.channels.ServerSocketChannel;
5 import java.util.Iterator;
6
7 public class TCPServerSelector {
8
9 private static final int BUFSIZE = 256; // Buffer size
(bytes)
10 private static final int TIMEOUT = 3000; // Wait timeout
(milliseconds)
11
12 public static void main(String[] args) throws
IOException {
13
14 if (args.length < 1) { // Test for correct # of args
15 throw new IllegalArgumentException("Parameter(s):
<Port> ...");
16 }
17
18 // Create a selector to multiplex listening sockets and
connections
19 Selector selector = Selector.open();
20
21 // Create listening socket channel for each port and
register selector
22 for (String arg : args) {
23 ServerSocketChannel listnChannel =
ServerSocketChannel.open();
24 listnChannel.socket().bind(new
InetSocketAddress(Integer.parseInt(arg)));
25 listnChannel.configureBlocking(false); // must be
nonblocking to register
26 // Register selector with channel. The returned key is
ignored
27 listnChannel.register(selector,
SelectionKey.OP_ACCEPT);
28 }
29
30 // Create a handler that will implement the protocol
31 TCPProtocol protocol = new
EchoSelectorProtocol(BUFSIZE);
32
33 while (true) { // Run forever, processing available I/O
operations
34 // Wait for some channel to be ready (or timeout)
35 if (selector.select(TIMEOUT) == 0) { // returns # of
ready chans
36 System.out.print(".");
37 continue;
38 }
39
40 // Get iterator on set of keys with I/O to process
41 Iterator<SelectionKey> keyIter =
selector.selectedKeys().iterator();
42 while (keyIter.hasNext()) {
43 SelectionKey key = keyIter.next(); // Key is bit mask
44 // Server socket channel has pending connection
requests?
45 if (key.isAcceptable()) {
46 protocol.handleAccept(key);
47 }
48 // Client socket channel has pending data?
49 if (key.isReadable()) {
50 protocol.handleRead(key);
51 }
52 // Client socket channel is available for writing and
53 // key is valid (i.e., channel not closed)?
54 if (key.isValid() && key.isWritable()) {
55 protocol.handleWrite(key);
56 }
57 keyIter.remove(); // remove from set of selected keys
58 }
59 }
60 }
61 }
TCPServerSelector.java
1.设置：第14-19行
验证至少有一个参数，创建一个Selector实例。
2.为每个端口创建一个ServerSocketChannel：第22-28行
创建一个ServerSocketChannel实例:第23行
使其侦听给定端口：第24行
需要获得底层的ServerSocket，并以端口号作为参数调用其bind()方法。任何超出适当数值范围的参数都将导致抛出IOException异常。
配置为非阻塞模式：第25行
只有非阻塞信道才可以注册选择器，因此需要将其配置为适当的状态。
为信道注册选择器：第27行
在注册过程中指出该信道可以进行"accept"操作。
3.创建协议操作器：第31行
为了访问回显协议中的操作方法，创建了一个EchoSelectorProtocol实例。该实例包含了需要用到的方法。
4.反复循环，等待I/O，调用操作器：第33-59行
选择：第35行
这个版本的select()方法将阻塞等待，直到有准备好I/O操作的信道，或直到发生了超时。该方法将返回准备好的信道数。返回0表示超时，这时程序将打印一个点来标记经过的时间和迭代次数。
获取所选择的键集：第41行
调用selectedKeys()方法返回一个Set实例，并从中获取一个Iterator。该集合中包含了每个准备好某一I/O操作的信道的SelectionKey（在注册时创建）。
在键集上迭代，检测准备好的操作：第42-58行
对于每个键，检查其是否准备好进行accep()操作，是否可读或可写，并调用相应的操作器方法对每种情况进行指定的操作。
从集合中移除键：第57行
由于select()操作只是向Selector所关联的键集合中添加元素，因此，如果不移除每个处理过的键，它就会在下次调用select()方法是仍然保留在集合中，而且可能会有无用的操作来调用它。
TCPServerSelector的大部分内容都与协议无关，只有协议赋值那一行代码是针对的特定协议。所有协议细节都包含在了TCPProtocol接口的具体实现中。EchoSelectorProtocol类就实现了该回显协议的操作器。你可以轻松地为自其他协议编写自己的操作器，或在我们的回显协议操作器上进行改进。
EchoSelectorProtocol.java
0 import java.nio.channels.SelectionKey;
1 import java.nio.channels.SocketChannel;
2 import java.nio.channels.ServerSocketChannel;
3 import java.nio.ByteBuffer;
4 import java.io.IOException;
5
6 public class EchoSelectorProtocol implements
TCPProtocol {
7
8 private int bufSize; // Size of I/O buffer
9
10 public EchoSelectorProtocol(int bufSize) {
11 this.bufSize = bufSize;
12 }
13
14 public void handleAccept(SelectionKey key) throws
IOException {
15 SocketChannel clntChan = ((ServerSocketChannel)
key.channel()).accept();
16 clntChan.configureBlocking(false); // Must be
nonblocking to register
17 // Register the selector with new channel for read and
attach byte buffer
18 clntChan.register(key.selector(), SelectionKey.
OP_READ, ByteBuffer.allocate(bufSize));
19
20 }
21
22 public void handleRead(SelectionKey key) throws
IOException {
23 // Client socket channel has pending data
24 SocketChannel clntChan = (SocketChannel)
key.channel();
25 ByteBuffer buf = (ByteBuffer) key.attachment();
26 long bytesRead = clntChan.read(buf);
27 if (bytesRead == -1) { // Did the other end close?
28 clntChan.close();
29 } else if (bytesRead > 0) {
30 // Indicate via key that reading/writing are both of
interest now.
31 key.interestOps(SelectionKey.OP_READ |
SelectionKey.OP_WRITE);
32 }
33 }
34
35 public void handleWrite(SelectionKey key) throws
IOException {
36 /*
37 * Channel is available for writing, and key is valid
(i.e., client channel
38 * not closed).
39 */
40 // Retrieve data read earlier
41 ByteBuffer buf = (ByteBuffer) key.attachment();
42 buf.flip(); // Prepare buffer for writing
43 SocketChannel clntChan = (SocketChannel)
key.channel();
44 clntChan.write(buf);
45 if (!buf.hasRemaining()) { // Buffer completely
written?
46 // Nothing left, so no longer interested in writes
47 key.interestOps(SelectionKey.OP_READ);
48 }
49 buf.compact(); // Make room for more data to be read
in
50 }
51
52 }32
EchoSelectorProtocol.java
1.声明实现TCPProtocol接口：第6行
2.成员变量和构造函数：第8-12行
每个实例都包含了将要为每个客户端信道创建的缓冲区大小。
3. handleAccept()：第14-20行
从键中获取信道，并接受连接：第15行
channel()方法返回注册时用来创建键的Channel。（我们知道该Channel是一个ServerSocketChannel，因为这是我们注册的惟一一种支持"accept"操作的信道。）accept()方法为传入的连接返回一个SocketChannel实例。
设置为非阻塞模式：第16行
再次提醒，这里无法注册阻塞式信道。
为信道注册选择器：第18-19行
可以通过SelectionKey类的selector()方法来获取相应的Selector。我们根据指定大小创建了一个新的ByteBuffer实例，并将其作为参数传递给register()方法。它将作为附件，与register()方法所返回的SelectionKey实例相关联。（在此我们忽略了返回的键，但当信道准备好读数据的I/O操作时，可以通过选出的键集对其进行访问。）
4. handleRead()：第22-33行
获取键关联的信道：第24行
根据其支持数据读取操作可知，这是一个SocketChannel。
获取键关联的缓冲区：第25行
连接建立后，有一个ByteBuffer附加到该SelectionKey实例上。
从信道中读数据：第27行
检查数据流的结束并关闭信道：第27-28行
如果read()方法返回-1，则表示底层连接已经关闭，此时需要关闭信道。关闭信道时，将从选择器的各种集合中移除与该信道关联的键。
如果接收完数据，将其标记为可写：第29-31行
注意，这里依然保留了信道的可读操作，虽然缓冲区中可能已经没有剩余空间了。
5. handleWrite()：第35-50行
获取包含数据的缓冲区：第41行
附加到SelectionKey上的ByteBuffer包含了之前从信道中读取的数据。
准备缓冲区的写操作：第42行
Buffer的内部状态指示了在哪里放入下一批数据，以及缓冲区还剩多少空间。flip()方法用来修改缓冲区的内部状态，以指示write()操作从什么地方获取数据，以及还有剩余多少数据。（下一章将对其进行详细介绍。）该方法的作用是使写数据的操作开始消耗由读操作产生的数据。
获取信道：第43行
向信道写数据：第44行
如果缓冲区为空，则标记为不再写数据：第45-48行
如果缓冲区中之前接收的数据已经没有剩余，则修改该键关联的操作集，指示其只能进行读操作。
压缩缓冲区：第49行
如果缓冲区中还有剩余数据，该操作则将其移动到缓冲区的前端，以使下次迭代能够读入更多的数据（第5.4.5节将对这个操作的语义进行详细介绍）。在任何情况下，该操作都将重置缓冲区的状态，因此缓冲区又变为可读。注意，除了在handleWrite()方法内部，与信道关联的缓冲区始终是设置为可读的。
现在我们已经准备好对三大NIO 抽象的细节进行深入研究了。
相关下载：
Java_TCPIP_Socket编程(doc)
http://download.csdn.net/detail/undoner/4940239
文献来源：
UNDONER(小杰博客) ：http://blog.csdn.net/undoner
LSOFT.CN(琅软中国) ：http://www.lsoft.cn