NIO中的一些概念理解

Selector

一个Selector可以管理多个channel，我们可以创建一个Selector，然后创建channel并将channel注册到Selector：

Selector Selector=Selector.open()；
channel.configureBlocking(false);
SelectionKey key= channel.register(selector,SelectionKey,OP_READ); //返回值是一个SelectionKey

从Selector类的源码中可以看出它里面维护了已注册的键集合、已就绪的键集合

public abstract class SelectorImpl extends AbstractSelector {
protected Set<SelectionKey> selectedKeys = new HashSet();  //已就绪的键集合。每个channel和Selector都对应一个SelectionKey，所以一个Selector中有一个SelectionKey的集合。
protected HashSet<SelectionKey> keys = new HashSet();   //已注册的键集合
private Set<SelectionKey> publicKeys;
private Set<SelectionKey> publicSelectedKeys;
... ...
}

SelectionKey: 它维护了Selector和channel的注册关系。从源码中可以看出SelectionKey中封装了channel、selector、channel中注册的事件集合、channel已经准备好的事件：

public class SelectionKeyImpl extends AbstractSelectionKey {
final SelChImpl channel;
public final SelectorImpl selector; 
private int index;
private volatile int interestOps;  //channel中注册的事件集合。 注意这里虽然是一个int值，但是可以通过与操作确定四个事件的存在与否  
private int readyOps;  //channel已经准备好的事件

所以：选择器维护注册过的通道的集合，并且这种注册关系都被封装在SelectionKey当中，又因为一个Selector管理着多个channel，所以Selector中封装了SelectionKey的集合，包括已注册的和注册并已就绪的。

Selector的select()方法返回的是已就绪的channel数量，它会阻塞直至有通道就绪才会返回。所以服务器只需要一个线程通过轮询并调用select方法监听是否有事件发生。如果有的话，直接迭代selectedKeys进行处理就行了：

 private void listener() throws Exception {
    while (true) {
        int n = selector.select();
        if (n == 0) {
            continue;
        }
        Iterator<SelectionKey> ite = selector.selectedKeys().iterator();
        while (ite.hasNext()) {
            SelectionKey key = ite.next();
            //a connection was accepted by a ServerSocketChannel.
            if (key.isAcceptable()) {
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                SocketChannel channel = server.accept();   //等待客户端连接
                registerChannel(selector, channel, SelectionKey.OP_READ);  //连接成功后像channel注册读事件
                remoteClientNum++;
                System.out.println("online client num="+remoteClientNum);
                replyClient(channel);
            }
            //a channel is ready for reading
            if (key.isReadable()) {
                readDataFromSocket(key);
            }

            ite.remove();//must
        }

    }
}

而在NIO中的操作就是调用channel的read和write方法，这两个方法将数据读写到Buffer。

  private void replyClient(SocketChannel channel) throws IOException {
    byteBuffer.clear();
    byteBuffer.put("hello client!\r\n".getBytes());
    byteBuffer.flip();
    channel.write(byteBuffer);
}

Buffer

flip(): NIO的Buffer机制中可以通过该方法来进行Buffer的读模式与写模式的切换，相当于一个Buffer实现了IO中的InputStream和OutputStream的功能。
所以是将Buffer中的数据写到channel和从channel读取数据到Buffer两个操作。其实write(Buffer)操作最终是将Buffer缓冲区数据的数据写到内存中，然后再通过网络传输，所以这里就分了Buffer和DirectBuffer等不同的Buffer，像DirectBuffer本身就是分配的堆外内存，所以数据直接放进去就行了，而普通的Buffer是堆内存储的，所以就需要多一个从堆内拷贝到堆外内存的过程：

static int read(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException {
    if (var1.isReadOnly()) {
        throw new IllegalArgumentException("Read-only buffer");
    } else if (var1 instanceof DirectBuffer) {
        return readIntoNativeBuffer(var0, var1, var2, var4);      //直接调用的native方法将数据放到堆外内存
    } else {
        ByteBuffer var5 = Util.getTemporaryDirectBuffer(var1.remaining());  //先分配堆外内存

        int var7;
        try {
            int var6 = readIntoNativeBuffer(var0, var5, var2, var4);  //再将Buffer数据拷贝过去
            var5.flip();
            if (var6 > 0) {
                var1.put(var5);
            }

            var7 = var6;
        } finally {
            Util.offerFirstTemporaryDirectBuffer(var5);
        }

        return var7;
    }
}