为什么选择NIO，那么NIO相对于IO来说，有什么优势，总结来说：
- IO是面向流的，数据只能从一端读取到另一端，不能随意读写。NIO则是面向缓冲区的，进行数据的操作更方便了
- IO是阻塞的，既浪费服务器的性能，也增加了服务器的风险；而NIO是非阻塞的。
- NIO引入了IO多路复用器，效率上更高效了。
在 NIO 中有几个比较关键的概念：Channel（通道），Buffer（缓冲区），Selector（选择器）
- Channel（通道）：通道，顾名思义，就是通向什么的道路，为某个提供了渠道。在传统 IO 中我们使用 Stream 来读取文件内容，因此可以将 NIO 中的 Channel 同传统 IO 中的 Stream 来类比，但是要注意，传统 IO 中，Stream 是单向的，比如 InputStream 只能进行读取操作，OutputStream 只能进行写操作。而 Channel 是双向的，既可用来进行读操作，又可用来进行写操作
- Buffer（缓冲区）：是NIO中非常重要的一个东西，在NIO中所有数据的读和写都离不开 Buffer，读取的数据只能放在Buffer中，同样地，写入数据也是先写入到Buffer中
- Selector（选择器）：是NIO中最关键的一个部分，Selector的作用就是用来轮询每个注册的Channel，一旦发现Channel有注册的事件发生，便获取事件然后进行处理。
用单线程处理一个Selector，然后通过 Selector.select() 方法来获取到达事件，在获取了到达事件之后，就可以逐个地对这些事件进行响应处理
Buffer
缓冲区，实际上是一个容器，是一个连续数组。Channel提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer。具体看下面这张图就理解了：
客户端发送数据时，必须先将数据存入Buffer中，然后将Buffer中的内容写入通道。服务端这边接收数据必须通过 Channel 将数据读入到 Buffer 中，然后再从 Buffer 中取出数据来处理。
Buffer 比较重要的变量如下：
- capacity：缓冲区的 capacity 表明可以储存在缓冲区中的最大数据容量。
- limit：变量表明还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)
- posistion：从通道读取时，指定了下一个字节将放到数组的哪一个元素中，如果您从通道中读三个字节到缓冲区中，那么缓冲区的 position 将会设置为3，指向数组中第四个元素；写入通道时，是从缓冲区中获取数据。 position 值跟踪从缓冲区中获取了多少数据。更准确地说，它指定下一个字节来自数组的哪一个元素。因此如果从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。
总结来说，NIO 的 Buffer有两种模式，读模式和写模式，默认是写模式，使用 flip() 可以切换到读模式
示例代码如下：
public static void main(String[] args) throws IOException{
//创建Buffer，分配128字节
ByteBuffer buffer=ByteBuffer.allocate(128);
System.out.println("创建Buffer，"+buffer);
//写入内容
String content="这个是内容";
buffer.put(content.getBytes());
System.out.println("写入内容，"+buffer);
//转换为读模式
buffer.flip();
System.out.println("切换为读模式，"+buffer);
//读取数据
byte[] v=new byte[buffer.remaining()];
buffer.get(v);
System.out.println("读取数据，"+buffer);
}
运行输出如下：
创建 Buffer，java.nio.HeapByteBuffer[pos=0 lim=128 cap=128]
写入内容，java.nio.HeapByteBuffer[pos=15 lim=128 cap=128]
切换为读模式，java.nio.HeapByteBuffer[pos=0 lim=15 cap=128]
读取数据，java.nio.HeapByteBuffer[pos=15 lim=15 cap=128]
访问方法
ByteBuffer 类中有四个 get() 方法：
- byte get();
- ByteBuffer get( byte dst[] );
- ByteBuffer get( byte dst[], int offset, int length );
- byte get( int index );
第一个方法获取单个字节。第二和第三个方法将一组字节读到一个数组中。第四个方法从缓冲区中的特定位置获取字节。那些返回 ByteBuffer 的方法只是返回调用它们的缓冲区的 this 值。
此外，我们认为前三个 get() 方法是相对的，而最后一个方法是绝对的。 相对意味着 get() 操作服从 limit 和 position 值，更明确地说，字节是从当前 position 读取的，而 position 在 get 之后会增加。另一方面，一个 绝对方法会忽略 limit 和 position 值，也不会影响它们。事实上，它完全绕过了缓冲区的统计方法。
上面列出的方法对应于 ByteBuffer 类。其他类有等价的 get() 方法，这些方法除了不是处理字节外，其它方面是是完全一样的，它们处理的是与该缓冲区类相适应的类型。
ByteBuffer 类中有五个 put() 方法：
- ByteBuffer put( byte b );
- ByteBuffer put( byte src[] );
- ByteBuffer put( byte src[], int offset, int length );
- ByteBuffer put( ByteBuffer src );
- ByteBuffer put( int index, byte b );
第一个方法 写入（put） 单个字节。第二和第三个方法写入来自一个数组的一组字节。第四个方法将数据从一个给定的源 ByteBuffer 写入这个 ByteBuffer。第五个方法将字节写入缓冲区中特定的 位置 。那些返回 ByteBuffer 的方法只是返回调用它们的缓冲区的 this 值。
与 get() 方法一样，我们将把 put() 方法划分为 相对 或者 绝对 的。前四个方法是相对的，而第五个方法是绝对的。
上面显示的方法对应于 ByteBuffer 类。其他类有等价的 put() 方法，这些方法除了不是处理字节之外，其它方面是完全一样的。它们处理的是与该缓冲区类相适应的类型
Channel
Channel 和传统 IO 中的 Stream 很相似。虽然很相似，但是有很大的区别，主要区别为通道是双向的，通过一个Channel既可以进行读，也可以进行写，常用的通道如下：
- FileChannel：可以从文件读或者向文件写入数据
- SocketChanel：以TCP来向网络连接的两端读写数据
- ServerSocketChannel：能够监听客户端发起的TCP连接，并为每个TCP连接创建一个新的SocketChannel来进行数据读写
- DatagramChannel：以UDP协议来向网络连接的两端读写数据
NIO 提供了多种通道对象，而所有的通道对象都实现了Channel 接口，他们之间的继承关系如下图：
我们将从一个文件中读取一些数据。如果使用原来的 I/O，那么我们只需创建一个 FileInputStream 并从它那里读取。在 NIO 中，情况稍有不同，我们首先从 FileInputStream 获取一个 Channel 对象，然后使用这个通道来读取数据。
在 NIO 系统中，任何时候执行一个读操作，都是从通道中读取，但是不是直接从通道读取。因为所有数据最终都驻留在缓冲区中，所以您是从通道读到缓冲区中。因此读取文件涉及三个步骤：
从 FileInputStream 获取 Channel
FileInputStream fin=new FileInputStream("readandshow.txt");
FileChannel fc=fin.getChannel();
创建 Buffer
ByteBuffer buffer=ByteBuffer.allocate(1024);
将数据从 Channel 读到 Buffer 中
fc.read(buffer);
写入文件和读取类似，首先需要从 FileOutputStream 获取一个通道
FileOutputStream fout=new FileOutputStream("writesomebytes.txt");
FileChannel fc=fout.getChannel();
创建一个缓冲区并在其中放入一些数据
byte[] message="message".getBytes();
ByteBuffer buffer=ByteBuffer.allocate(1024);
for(byte aMessage:message){
buffer.put(aMessage);
}
buffer.flip();
最后一步是写入缓冲区中
fc.write(buffer);
Selector
Selector 类是 NIO 的核心类，Selector 能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的响应处理。这样一来，只是用一个单线程就可以管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。与Selector 有关的一个关键类是 SelectionKey，一个 SelectionKey 表示一个到达的事件，这2个类构成了服务端处理业务的关键逻辑。
我们创建一个服务器套接字程序，需要做的第一件事就是创建一个 Selector 对象
//创建S elector
Selector selector=Selector.open();
为了接收连接，我们需要一个 ServerSocketChannel，事实上，我们要监听的每一个端口都需要有一个 ServerSocketChannel ，如下所示
//创建ServerSocketChannel并设置非阻塞，绑定到端口
ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
ServerSocket serverSocket=serverSocketChannel.socket();
InetSocketAddress inetSocketAddress=new InetSocketAddress(9990);
serverSocket.bind(inetSocketAddress);
打开的 ServerSocketChannels 注册到 Selector上，为此我们使用 ServerSocketChannel.register() 方法
//注册事件OP_ACCEPT表示监听accept事件，也就是在新的连接建立时所发生的事件，
//其返回的SelectionKey用于后续的取消注册
SelectionKey selectionKey=serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
我们调用 Selector 的 select() 方法，这个方法会阻塞，直到至少有一个已注册的事件发生，当一个或者更多的事件发生时， select() 方法将返回所发生的事件的数量。
//阻塞，直到有注册的事件发生，返回发生事件的数量
int num=selector.select();
接下来，我们调用 Selector 的 selectedKeys() 方法，它返回发生了事件的 SelectionKey 对象的一个 集合 。
//返回发生事件的SelectionKey集合
SetselectedKeys=selector.selectedKeys();
我们通过迭代 SelectionKeys 并依次处理每个 SelectionKey 来处理事件，对于每一个 SelectionKey，您必须确定发生的是什么 I/O 事件，以及这个事件影响哪些 I/O 对象，在处理完成后，需要迭代器中移除，防止多次处理。
//迭代集合依次处理
Iterator it=selectedKeys.iterator();
while(it.hasNext()){
SelectionKeykey=(SelectionKey)it.next();
// 针对事件类型进行处理
if((key.readyOps()&SelectionKey.OP_ACCEPT)==SelectionKey.OP_ACCEPT){
// 服务器套接字有传入连接在等待，操作accept接受连接
ServerSocketChannel ssc=(ServerSocketChannel)key.channel();
SocketChannel sc=ssc.accept();
// 配置为非阻塞
sc.configureBlocking(false);
// 注册事件OP_READ表示监听读取
SelectionKey newKey=sc.register(selector,SelectionKey.OP_READ);
}
if((key.readyOps()&SelectionKey.OP_READ)==SelectionKey.OP_READ){
// 处理接收数据事件
}
//处理完成后，从集合中移除
it.remove();
}