java NIO

为什么要使用 NIO?

    NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统，因而可以极大地提高速度。

   原来的 I/O 库(在 java.io.*中) 与 NIO 最重要的区别是数据打包和传输的方式。原来的 I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。

    面向流 的 I/O 系统一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器，以便每个过滤器只负责单个复杂处理机制的一部分，这样也是相对简单的。不利的一面是，面向流的 I/O 通常相当慢。

    一个 面向块 的 I/O 系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。

    在 JDK 1.4 中原来的 I/O 包和 NIO 已经很好地集成了。 java.io.* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如， java.io.* 包中的一些类包含以块的形式读写数据的方法，这使得即使在更面向流的系统中，处理速度也会更快。

    也可以用 NIO 库实现标准 I/O 功能。例如，可以容易地使用块 I/O 一次一个字节地移动数据。但是正如您会看到的，NIO 还提供了原 I/O 包中所没有的许多好处。

在网络通信方面：传统的并发型服务器设计是利用阻塞型网络I/O 以多线程的模式来实现的，然而由于系统常常在进行网络读写时处于阻塞状态，会大大影响系统的性能；自Java1. 4 开始引入了NIO(新I/O) API，通过使用非阻塞型I/O，实现流畅的网络读写操作，为开发高性能并发型服务器程序提供了一个很好的解决方案，这就是java nio。

Java NIO：

Java NIO中比较核心的三个概念是：通道（Channel）、缓冲区（Buffer）、选择器（Selector）。

什么是通道？

Channel是一个对象，可以通过它读取和写入数据。拿 NIO 与原来的 I/O 做个比较，通道就像是流。

所有数据都通过 Buffer 对象来处理。您永远不会将字节直接写入通道中，相反，您是将数据写入包含一个或者多个字节的缓冲区。同样，您不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)， 而 通道 可以用于读、写或者同时用于读写。

因为它们是双向的，所以通道可以比流更好地反映底层操作系统的真实情况。特别是在 UNIX 模型中，底层操作系统通道是双向的。

常用的有以下几种通道：

• FileChannel  --从文件读或者向文件写入数据
• SocketChanel   --以TCP来向网络连接的两端读写数据
• ServerSocketChannel   --服务器端通过ServerSocketChanel能够监听客户端发起的TCP连接，并为每个TCP连接创建一个新的SocketChannel来进行数据读写
• DatagramChannel   --以UDP协议来向网络连接的两端读写数据

什么是缓冲区？

Buffer 是一个对象， 它包含一些要写入或者刚读出的数据。 在 NIO 中加入 Buffer 对象，体现了新库与原 I/O 的一个重要区别。在面向流的 I/O 中，您将数据直接写入或者将数据直接读到 Stream 对象中。

在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，您都是将它放到缓冲区中。

Buffer实际上是一个容器，是一个连续数组。Channel提供从文件、网络读取数据的渠道，使用Java NIO时，所有数据处理（读取或写入）必须经由Buffer。即读入数据时，先通过通道Channel获取数据渠道，然后将数据写入到缓冲区Buffer中，往外写数据时，先把内存中的数据放到Buffer中，然后再从Buffer送往通道中。如下图所示：

最常用的缓冲区类型是 ByteBuffer。一个 ByteBuffer 可以在其底层字节数组上进行 get/set 操作(即字节的获取和设置)。

ByteBuffer 不是 NIO 中唯一的缓冲区类型。事实上，对于每一种基本 Java 类型都有一种缓冲区类型：

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer

每一个 Buffer 类都是 Buffer 接口的一个实例。 除了 ByteBuffer，每一个 Buffer 类都有完全一样的操作，只是它们所处理的数据类型不一样。因为大多数标准 I/O 操作都使用 ByteBuffer，所以它具有所有共享的缓冲区操作以及一些特有的操作。

一个传统IO读写数据的例子：    

[java] view plain copy

 

1. public static String readFromStream(InputStream is) throws IOException{  
2.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
3.         byte[] buffer = new byte[1024];  
4.         int len = 0;  
5.         while((len = is.read(buffer))!=-1){  
6.             baos.write(buffer, 0, len);  
7.         }  
8.         is.close();  
9.         String result = baos.toString();  
10.         baos.close();  
11.         return result;  
12.     }  

传统IO在读取数据时，直接从InputStream中读入到byte[]数组中，如is.read(buffer)，在写数据时，直接将内存数据写到输出流中,如baos.write(buffer,0,len);

使用NIO读取数据：按照上图，读取数据时，从通道中将数据读入到Buffer中，写数据时，将内存数据先写到Buffer，再送入通道。

    NIO 读取数据：        

[java] view plain copy

 

1. FileInputStream in = new FileInputStream("e:\\lly.txt");  
2.         FileChannel fileChannel = in.getChannel();  
3.         //创建一个ByteBuffer缓冲区  
4.         ByteBuffer buffer = ByteBuffer.allocate(10);  
5.         //从通道读入数据到缓冲区  
6.         fileChannel.read(buffer);  
7.         //重设此缓冲区，将限制设置为当前位置，然后将当前位置设置为0    
8.         buffer.flip();  
9.   
10.         while(buffer.hasRemaining()){  
11.             byte b = buffer.get();//从缓冲区中取数据到内存中  
12.             System.out.print(((char)b));  
13.         }  
14.         in.close();  

    NIO写数据：       

[java] view plain copy

 

1. //模拟数据  
2.    byte[] data = { 83, 111, 109, 101, 32,    
3.            98, 121, 116, 101, 115, 46};  
4.    FileOutputStream out = new FileOutputStream("e:\\lly.txt");  
5.    FileChannel fileChannel = out.getChannel();  
6.    //创建一个ByteBuffer缓冲区  
7.    ByteBuffer buffer = ByteBuffer.allocate(20);  
8.    //先将数据写入到Buffer中  
9.    for(int i = 0; i < data.length; i++){  
10.        buffer.put(data[i]);  
11.    }  
12.    //重设此缓冲区，将限制设置为当前位置，然后将当前位置设置为0   
13.    buffer.flip();  
14.    //把buffer中的数据送入到通道中  
15.    fileChannel.write(buffer);  
16.    out.close();  

可以看到，Java NIO在数据处理方面需要通过Buffer来缓存，与传统IO处理方式相比，NIO相当于是数据块处理，传统IO是一个一个字节处理。其实，在传统IO后面出现了BufferInputStream、BufferOutputStream这种也是缓存数据块的处理方式。

同时，我们看到在读或写时都调用了Buffer的buffer.flip();这个方法非常重要，它是用来设置缓冲对象的一些状态信息，在读get()和写put()之前，都需要调用buffer.flip();来设置状态。

缓冲区内部细节

NIO 中两个重要的缓冲区组件：状态变量和访问方法 (accessor)。

每一个读/写操作都会改变缓冲区的状态。通过记录和跟踪这些变化，缓冲区就可能够内部地管理自己的资源。

在从通道读取数据时，数据被放入到缓冲区。在有些情况下，可以将这个缓冲区直接写入另一个通道，但是在一般情况下，您还需要查看数据。这是使用 访问方法 get() 来完成的。同样，如果要将原始数据放入缓冲区中，就要使用访问方法 put()。

状态变量：

可以用三个值指定缓冲区在任意时刻的状态：

• position
• limit
• capacity

这三个变量一起可以跟踪缓冲区的状态和它所包含的数据。接下来将详细分析每一个变量，还要介绍它们如何适应典型的读/写(输入/输出)进程。在这个例子中，我们假定要将数据从一个输入通道拷贝到一个输出通道。

position：指定了下一个将要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新创建一个Buffer对象时，position被初始化为0。

limit：指定还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。

capacity：指定了可以存储在缓冲区中的最大数据容量，实际上，它指定了底层数组的大小，或者至少是指定了准许我们使用的底层数组的容量。

以上四个属性值之间有一些相对大小的关系：0 <= position <= limit <= capacity。

我们首先观察一个新创建的缓冲区。出于本例子的需要，我们假设这个缓冲区的 总容量 为8个字节。 Buffer 的状态如下所示：

 

limit 决不能大于 capacity，此例中这两个值都被设置为 8。我们通过将它们指向数组的尾部之后(如果有第8个槽，则是第8个槽所在的位置)来说明这点。

 

position 设置为0。如果我们读一些数据到缓冲区中，那么下一个读取的数据就进入 slot 0 。如果我们从缓冲区写一些数据，从缓冲区读取的下一个字节就来自 slot 0 。 position 设置如下所示：

 

由于 capacity 不会改变，所以我们在下面的讨论中可以忽略。

第一次读取：

现在我们可以开始在新创建的缓冲区上进行读/写操作。首先从输入通道中读一些数据到缓冲区中。第一次读取得到三个字节。它们被放到数组中从 position 开始的位置，这时 position 被设置为 0。读完之后，position 就增加到 3，如下所示：

 

limit 没有改变。

第二次读取

在第二次读取时，我们从输入通道读取另外两个字节到缓冲区中。这两个字节储存在由 position 所指定的位置上， position 因而增加 2：

 

limit 没有改变。

flip()方法

现在我们要将数据写到输出通道中。在这之前，我们必须调用 flip() 方法。这个方法做两件非常重要的事：

1. 它将 limit 设置为当前 position。
2. 它将 position 设置为 0。

buffer.flip()该方法是用于将缓冲区从写模式切换到读模式，这是一种固定写法，该方法的源码如下：

public final Buffer flip() {    limit = position;    position = 0;    mark = -1;    return this;}

前一小节中的图显示了在 flip 之前缓冲区的情况。下面是在 flip 之后的缓冲区：

 

我们现在可以将数据从缓冲区写入通道了。 position 被设置为 0，这意味着我们得到的下一个字节是第一个字节。 limit 已被设置为原来的 position，这意味着它包括以前读到的所有字节，并且一个字节也不多。

第一次写入：

在第一次写入时，我们从缓冲区中取四个字节并将它们写入输出通道。这使得 position 增加到 4，而 limit 不变，如下所示：

 

第二次写入：

我们只剩下一个字节可写了。 limit在我们调用 flip() 时被设置为 5，并且 position 不能超过 limit。所以最后一次写入操作从缓冲区取出一个字节并将它写入输出通道。这使得 position 增加到 5，并保持 limit 不变，如下所示：

 

clear()方法

最后一步是调用缓冲区的 clear() 方法。这个方法重设缓冲区以便接收更多的字节。 Clear 做两种非常重要的事情：

1. 它将 limit 设置为与 capacity 相同。
2. 它设置 position 为 0。

 public final Buffer clear() {    position = 0;     limit = capacity;     mark = -1;     return this;}

1、一旦完成对buffer中数据的读取，需要让buffer做好再次被写入的准备，这时候可以调用clear方法来完成。

2、clear方法将position设置为0，limit设置为容量的值，也就意味着buffer被清空了，但是这个清空的概念是写入数据可以从缓冲区的指定位置开始，但buffer里面的数据并没有        删除。

3、如果buffer里面还有数据没有被读取，这个时候调用clear方法会导致那些数据被“遗忘”，因为没有标记告诉你哪些是读取过哪些没有被读取。

下图显示了在调用 clear() 后缓冲区的状态：

 

缓冲区现在可以接收新的数据了。

选择器（Selector）

    Selector类是NIO的核心类，Selector能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的响应处理。这样一来，只是用一个单线程就可以管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。如下如所示：

要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。

JAVA NIO socket用法

传统的阻塞型网络 I/O的不足：
    Java 平台传统的I/O 系统都是基于Byte（字节）和Stream（数据流）的，相应的I/O 操作都是阻塞型的，所以服务器程序也采用阻塞型I/O 进行数据的读、写操作。
    这种模式的优点是简单、实用、易管理；然而缺点也是显而易见的：由于是为每一个客户端分配一个线程来处理输入、输出数据，其线程与客户机的比例近似为1：1，随着线程数量的不断增加，服务器启动了大量的并发线程，会大大加大系统对线程的管理开销，这将成为吞吐量瓶颈的主要原因；其次由于底层的I/O 操作采用的同步模式，I/O 操作的阻塞管理粒度是以服务于请求的线程为单位的,有可能大量的线程会闲置,处于盲等状态，造成I/O资源利用率不高，影响整个系统的性能。

   对于并发型服务器，系统用在阻塞型I/O 等待和线程间切换的时间远远多于CPU 在内存中处理数据的时间，因此传统的阻塞型I/O 已经成为制约系统性能的瓶颈。Java1.4 版本后推出的NIO 工具包，提供了非阻塞型I/O 的异步输入输出机制，为提高系统的性能提供了可实现的基础机制。

NIO 包及工作原理

    针对传统I/O 工作模式的不足，NIO 工具包提出了基于Buffer（缓冲区）、Channel（通道）、Selector（选择器）的新模式；Selector（选择器）、可选择的Channel（通道）SelectionKey（选择键）配合起来使用，可以实现并发的非阻塞型I/O 能力。

NIO 工具包的成员

• Buffer（缓冲器）
  Buffer 类是一个抽象类，它有7 个子类分别对应于七种基本的数据类型：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer 和ShortBuffer。每一个Buffer对象相当于一个数据容器，可以把它看作内存中的一个大的数组，用来存储和提取所有基本类型(boolean 型除外)的数据。Buffer 类的核心是一块内存区，可以直接对其执行与内存有关的操作，利用操作系统特性和能力提高和改善Java 传统I/O 的性能。

• Channel（通道）
  Channel 被认为是NIO 工具包的一大创新点，是(Buffer)缓冲器和I/O 服务之间的通道，具有双向性，既可以读入也可以写出，可以更高效的传递数据。我们这里主要讨论的是ServerSocketChannel 和SocketChannel，它们都继承了SelectableChannel，是可选择的通道，分别可以工作在同步和异步两种方式下（这里的可选择不是指可以选择两种工作方式，而是指可以有选择的注册自己感兴趣的事件）。当通道工作在同步方式时，它的功能和编程方法与传统的ServerSocket、Socket 对象相似；当通道工作在异步工作方式时，进行输入输出处理不必等到输入输出完毕才返回，并且可以将其感兴趣的（如：接受操作、连接操作、读出操作、写入操作）事件注册到Selector 对象上，与Selector 对象协同工作可以更有效率的支持和管理并发的网络套接字连接。
• Selector（选择器）
  各类 Buffer 是数据的容器对象；各类Channel 实现在各类Buffer 与各类I/O 服务间传输数据。Selector 是实现并发型非阻塞I/O 的核心，各种可选择的通道将其感兴趣的事件注册到Selector 对象上，Selector 在一个循环中不断轮循监视这各些注册在其上的Socket 通道。为ServerSocketChannel 监控接收客户端连接就绪事件，为 SocketChannel 监控连接服务器就绪，读就绪和写就绪事件。
• ServerSocketChannel
  ServerSocket 的替代类，支持阻塞通信与非阻塞通信。
• SocketChannel
  Socket 的替代类，支持阻塞通信与非阻塞通信。
• SelectionKey
      SelectionKey 类则封装了SelectableChannel 对象在Selector 中的注册信息。当Selector 监测到在某个注册的SelectableChannel 上发生了感兴趣的事件时,自动激活产生一个SelectionKey对象，这个对象中记录了哪一个SelectableChannel 上发生了哪种事件，通过对被激活的SelectionKey 的分析,外界可以知道每个SelectableChannel 发生的具体事件类型,进行相应的处理。当一个 SelectionKey 对象位于Selector 对象的 selected-keys 集合中时，就表示与这个 SelectionKey 对象相关的事件发生了。
• 在SelectionKey 类中几个静态常量
  SelectionKey.OP_ACCEPT     ->   客户端连接就绪事件 等于监听serversocket.accept()返回一个socket
  SelectionKey.OP_CONNECT  ->   准备连接服务器就绪 跟上面类似,只不过是对于socket的 相当于监听了 socket.connect()
  SelectionKey.OP_READ        ->   读就绪事件, 表示输入流中已经有了可读数据, 可以执行读操作了
  SelectionKey.OP_WRITE       ->   写就绪事件

 

    在使用传统的ServerSocket和Socket的时候 很多时候程序是会阻塞的。比如 serversocket.accept() , socket.getInputStream().read() 的时候都会阻塞 。

    accept()方法除非等到客户端socket的连接或者被异常中断 否则会一直等待下去，read()方法也是如此 除非在输入流中有了足够的数据，否则该方法也会一直等待下去知道数据的到来。在ServerSocket与Socket的方式中 服务器端往往要为每一个客户端(socket)分配一个线程,而每一个线程都有可能处于长时间的阻塞状态中.而过多的线程也会影响服务器的性能，在JDK1.4引入了非阻塞的通信方式，这样使得服务器端只需要一个线程就能处理所有客户端socket的请求。

NIO 工作原理

    通过上面的讨论，我们可以看出在并发型服务器程序中使用NIO，实际上是通过网络事件驱动模型实现的。我们应用Select 机制，不用为每一个客户端连接新启线程处理，而是将其注册到特定的Selector 对象上，这就可以在单线程中利用Selector 对象管理大量并发的网络连接，更好的利用了系统资源；采用非阻塞I/O 的通信方式，不要求阻塞等待I/O 操作完成即可返回，从而减少了管理I/O 连接导致的系统开销，大幅度提高了系统性能。

   当有读或写等任何注册的事件发生时，可以从Selector 中获得相应的SelectionKey ， 从SelectionKey 中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。由于在非阻塞网络I/O 中采用了事件触发机制，处理程序可以得到系统的主动通知，从而可以实现底层网络I/O 无阻塞、流畅地读写，而不像在原来的阻塞模式下处理程序需要不断循环等待。使用NIO，可以编写出性能更好、更易扩展的并发型服务器程序。

并发型服务器程序的实现代码

    应用 NIO 工具包，基于非阻塞网络I/O 设计的并发型服务器程序与以往基于阻塞I/O 的实现程序有很大不同，在使用非阻塞网络I/O 的情况下，程序读取数据和写入数据的时机不是由程序员控制的，而是Selector 决定的。下面便给出基于非阻塞网络I/O 的并发型服务器程序的核心代码片段：

<span style="font-size:14px;"><span style="font-size:14px;">import java.io.IOException;import java.net.InetSocketAddress;import java.net.ServerSocket;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;import java.util.Set;public class NIOServer {    /*标识数字*/    private int flag = 0;    /*缓冲区大小*/    private int BLOCK = 4096;    /*接受数据缓冲区*/    private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);    /*发送数据缓冲区*/    private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);    private Selector selector;    public NIOServer(int port) throws IOException {        // 打开服务器套接字通道          ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();        // 服务器配置为非阻塞          serverSocketChannel.configureBlocking(false);        // 检索与此通道关联的服务器套接字          ServerSocket serverSocket = serverSocketChannel.socket();        // 进行服务的绑定          serverSocket.bind(new InetSocketAddress(port));        // 通过open()方法找到Selector          selector = Selector.open();        // 注册到selector，等待连接          serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);        System.out.println("Server Start----8888:");    }    // 监听      private void listen() throws IOException {        while (true) {            // 应用Select机制轮循是否有用户感兴趣的新的网络事件发生，当没有新的网络事件发生时，此方法会阻塞，直到有新的网络事件发生为止。            selector.select();            // 返回此选择器的已选择键集。              Set<SelectionKey> selectionKeys = selector.selectedKeys();            Iterator<SelectionKey> iterator = selectionKeys.iterator();            System.out.println("selectionKeys size -> " + selectionKeys.size());            while (iterator.hasNext()) {                SelectionKey selectionKey = iterator.next();                iterator.remove();                handleKey(selectionKey);            }        }    }    // 处理请求      private void handleKey(SelectionKey selectionKey) throws IOException {        // 接受请求          ServerSocketChannel server = null;        SocketChannel client = null;        String receiveText;        String sendText;        int count = 0;        // 测试此键的通道是否已准备好接受新的套接字连接。          if (selectionKey.isAcceptable()) {            System.out.println("------------- isAcceptable");            // 返回为之创建此键的通道。              server = (ServerSocketChannel) selectionKey.channel();            // 接受到此通道套接字的连接。              // 此方法返回的套接字通道（如果有）将处于阻塞模式。              client = server.accept();            // 配置为非阻塞              client.configureBlocking(false);            //在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。            client.register(selector, SelectionKey.OP_READ);        }        else if (selectionKey.isReadable()) {            System.out.println("------------- isReadable");            // 返回为之创建此键的通道。              client = (SocketChannel) selectionKey.channel();            //将缓冲区清空以备下次读取              receivebuffer.clear();            //读取服务器发送来的数据到缓冲区中              count = client.read(receivebuffer);            if (count > 0) {                receiveText = new String(receivebuffer.array(), 0, count);                System.out.println("服务器端接受客户端数据--:" + receiveText);                client.register(selector, SelectionKey.OP_WRITE);            }        }        else if (selectionKey.isWritable()) {            System.out.println("------------- isWritable");            //将缓冲区清空以备下次写入              sendbuffer.clear();            // 返回为之创建此键的通道。              client = (SocketChannel) selectionKey.channel();            sendText = "message from server--" + flag++;            //向缓冲区中输入数据              sendbuffer.put(sendText.getBytes());            //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位              sendbuffer.flip();            //输出到通道              client.write(sendbuffer);            System.out.println("服务器端向客户端发送数据--：" + sendText);            client.register(selector, SelectionKey.OP_READ);        }    }    /**      * @param args      * @throws IOException      */    public static void main(String[] args) throws IOException {        // TODO Auto-generated method stub          int port = 8888;        NIOServer server = new NIOServer(port);        server.listen();    }}</span></span>

<span style="font-size:14px;"><span style="font-size:14px;">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.SocketChannel;import java.util.Iterator;import java.util.Set;public class NIOClient {    /*标识数字*/    private static int flag = 0;    /*缓冲区大小*/    private static int BLOCK = 4096;    /*接受数据缓冲区*/    private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);    /*发送数据缓冲区*/    private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);    /*服务器端地址*/    private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress("localhost", 8888);    public static void main(String[] args) throws IOException {        // TODO Auto-generated method stub          // 打开socket通道          SocketChannel socketChannel = SocketChannel.open();        // 设置为非阻塞方式          socketChannel.configureBlocking(false);        // 打开选择器          Selector selector = Selector.open();        // 注册连接服务端socket动作          socketChannel.register(selector, SelectionKey.OP_CONNECT);        // 连接          socketChannel.connect(SERVER_ADDRESS);        // 分配缓冲区大小内存          Set<SelectionKey> selectionKeys;        Iterator<SelectionKey> iterator;        SelectionKey selectionKey;        SocketChannel client;        String receiveText;        String sendText;        int count = 0;        while (true) {            //选择一组键，其相应的通道已为 I/O 操作准备就绪。              //此方法执行处于阻塞模式的选择操作。              selector.select();            //返回此选择器的已选择键集。              selectionKeys = selector.selectedKeys();            //System.out.println(selectionKeys.size());              iterator = selectionKeys.iterator();            while (iterator.hasNext()) {                selectionKey = iterator.next();                if (selectionKey.isConnectable()) {                    System.out.println("client connect");                    client = (SocketChannel) selectionKey.channel();                    // 判断此通道上是否正在进行连接操作。                      // 完成套接字通道的连接过程。                      if (client.isConnectionPending()) {                        client.finishConnect();                        System.out.println("完成连接!");                        sendbuffer.clear();                        sendbuffer.put("Hello,Server".getBytes());                        sendbuffer.flip();                        client.write(sendbuffer);                    }                    client.register(selector, SelectionKey.OP_READ);                }                else if (selectionKey.isReadable()) {                    client = (SocketChannel) selectionKey.channel();                    //将缓冲区清空以备下次读取                      receivebuffer.clear();                    //读取服务器发送来的数据到缓冲区中                      count = client.read(receivebuffer);                    if (count > 0) {                        receiveText = new String(receivebuffer.array(), 0, count);                        System.out.println("客户端接受服务器端数据--:" + receiveText);                        client.register(selector, SelectionKey.OP_WRITE);                    }                }                else if (selectionKey.isWritable()) {                    sendbuffer.clear();                    client = (SocketChannel) selectionKey.channel();                    sendText = "message from client--" + (flag++);                    sendbuffer.put(sendText.getBytes());                    //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位                      sendbuffer.flip();                    client.write(sendbuffer);                    System.out.println("客户端向服务器端发送数据--：" + sendText);                    client.register(selector, SelectionKey.OP_READ);                }            }            selectionKeys.clear();        }    }}</span></span>

从上面对代码可以看出，使用非阻塞性I/O进行并发型服务器程序设计分三个部分：

1. 向Selector对象注册感兴趣的事件。
2. 从Selector中获取所感兴趣的事件。
3. 根据不同的事件进行相应的处理。

结语

    通过使用NIO 工具包进行并发型服务器程序设计，一个或者很少几个Socket 线程就可以处理成千上万个活动的Socket 连接，大大降低了服务器端程序的开销；同时网络I/O 采取非阻塞模式，线程不再在读或写时阻塞，操作系统可以更流畅的读写数据并可以更有效地向CPU 传递数据进行处理，以便更有效地提高系统的性能。