Java基础：同步非阻塞式IO（NIO）

转载请注明出处：jiq•钦's technical Blog 

引言

JDK1.4中引入了NIO，即New IO，目的在于提高IO速度。特别注意JavaNIO不完全是非阻塞式IO(No-Blocking IO)，因为其中部分通道(如FileChannel)只能运行在阻塞模式下，而其他的通道可以在阻塞式和非阻塞式之间进行选择。

尽管这样，我们还是习惯将Java NIO看作是非阻塞式IO，而前面介绍的面向流(字节/字符)的IO类库则是非阻塞的，详细来看，两者区别如下：

IO	NIO
面向流(Stream oriented)	面向缓冲区(Buffer oriented)
阻塞式(Blocking IO)	非阻塞式(Non blocking IO)
无	选择器(Selectors)

但是千万记住，两者没有孰优孰劣，NIO是java io的拓展，根据不同的场景，两者各有用处。

 

面向流与面向缓冲

Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 JavaIO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

 

阻塞与非阻塞IO

Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

 

选择器（Selectors）

Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

 

Java NIO最关键的三个概念分别是通道，缓冲区和选择器：

一、通道（Channel）

Java NIO的通道类似流，但又有些不同：

n  通道是双向的，可读也可写，而流的读写是单向的。

n  通道可以异步地读写。

n  无论读写，通道只能和Buffer交互。

 

JavaNIO中最重要的几个Channel的实现：

u  FileChannel：从文件中读写数据。

u  DatagramChannel：通过UDP读写网络中的数据。

u  SocketChannel：通过TCP读写网络中的数据。

u  ServerSocketChannel：可以监听新进来的TCP连接，像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。

 

下面是一个通过FileChannel来向文件中写入数据的例子：

public class Test {
   public static void main(String[] args) throws IOException  {
       File file = new File("test.txt");
       FileOutputStream os = new FileOutputStream(file);
       FileChannel channel = os.getChannel();
       ByteBuffer buffer = ByteBuffer.allocate(1024);
       String str = "hello,jiyiqin";
       buffer.put(str.getBytes());
       buffer.flip();
       channel.write(buffer);
       channel.close();
       os.close();
   } 
}

备注：上面示例有两个关键的地方：

（1）一个是通过FileOutputStream文件输出流获取通道，旧的IO类库(或者说面向流的IO类库)中FileInputStream/FileOutputStream和RandomAccessFile三个类被修改以能够产生FileChannel通道，但是面向字符的流Reader/Writer不能产生通道。

（2）另外在将缓冲区数据写入通道之前必须要调用缓冲区的flip方法转换为读模式，让通道可从缓冲区读取数据。

二、缓冲区（Buffer）

Java NIO中的Buffer用于和NIO通道进行交互，数据是从通道读入缓冲区或从缓冲区写入到通道中。当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

下面是一个从文件通道FileChannel读取数据的例子：

RandomAccessFile aFile = newRandomAccessFile("data/nio-data.txt", "rw"); 
FileChannel inChannel =aFile.getChannel(); 
ByteBuffer buf = ByteBuffer.allocate(48); 
int bytesRead = inChannel.read(buf);
while (bytesRead != -1) { 
 buf.flip();  //使缓冲区可读
 while(buf.hasRemaining()){
     System.out.print((char)buf.get()); //一次读取一字节
  }
 buf.clear();
  bytesRead= inChannel.read(buf);
}
aFile.close();

三、选择器（Selector）

Selector允许单线程处理多个Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。例如，在一个聊天服务器中。

仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道。对于操作系统来说，线程之间上下文切换的开销很大，而且每个线程都要占用系统的一些资源（如内存）。因此，使用的线程越少越好。

但是，需要记住，现代的操作系统和CPU在多任务方面表现的越来越好，所以多线程的开销随着时间的推移，变得越来越小了。实际上，如果一个CPU有多个内核，不使用多任务可能是在浪费CPU能力。不管怎么说，关于那种设计的讨论应该放在另一篇不同的文章中。在这里，只要知道使用Selector能够处理多个通道就足够了。

下图用一张转载的图展示在一个单线程中使用一个Selector处理3个Channel：

步骤1：Selector的创建

通过调用Selector.open()方法创建一个Selector，如下：

Selectorselector = Selector.open(); 

步骤2：向Selector注册通道

为了将Channel和Selector配合使用，实现单个线程处理多个通道的梦想，必须将channel注册到selector上。可以通过SelectableChannel.register()方法来实现，如下：

channel.configureBlocking(false); 
SelectionKey key= channel.register(selector, Selectionkey.OP_READ);

其中第一句代码设置通道为非阻塞模式，然后第二句向selector注册该通道。register()方法的第二个参数。这是一个“interest集合”，意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件：

SelectionKey.OP_CONNECT

SelectionKey.OP_ACCEPT

SelectionKey.OP_READ

SelectionKey.OP_WRITE

特别注意：与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，因为FileChannel不能切换到非阻塞模式(因为其本身特性，要注意这里指的文件和Linux中的文件不同，Linux中的文件可以是代表磁盘文件、打印机设备、网卡等，而这里说的文件就只是磁盘文件)。而套接字通道都可以。

 

步骤3：阻塞监视通道

一旦向Selector注册了一或多个通道，就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如连接、接受、读或写）已经准备就绪的那些通道。换句话说，如果你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。 

下面是select()方法：

int select()
int select(long timeout)
int selectNow()

select()阻塞到至少有一个通道在你注册的事件上就绪了。

select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。

selectNow()不会阻塞，不管什么通道就绪都立刻返回（译者注：此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，则此方法直接返回零。）。

 

步骤4：遍历selectedKeys()访问就绪通道

一旦调用了select()方法，并且返回值表明有一个或更多个通道就绪了，然后可以通过调用selector的selectedKeys()方法，访问“已选择键集（selected key set）”中的就绪通道。如下所示：

Set selectedKeys =selector.selectedKeys(); 

可以遍历这个已选择的键集合来访问就绪的通道。

 

下面给出一个完整的Channel和Selector结合的例子：

Selector selector = Selector.open(); 
channel.configureBlocking(false); 
SelectionKey key =channel.register(selector, SelectionKey.OP_READ); 
while(true) { 
  intreadyChannels = selector.select(); 
 if(readyChannels == 0) continue; 
  SetselectedKeys = selector.selectedKeys(); 
 Iterator keyIterator = selectedKeys.iterator(); 
 while(keyIterator.hasNext()) { 
   SelectionKey key = keyIterator.next(); 
   if(key.isAcceptable()) { 
       // a connection was accepted by a ServerSocketChannel. 
    }else if (key.isConnectable()) { 
       // a connection was established with a remote server. 
    }else if (key.isReadable()) { 
       // a channel is ready for reading 
    }else if (key.isWritable()) { 
       // a channel is ready for writing 
   } 
 } 
} 

非阻塞式IO = 选择器+套接字通道：

套接字通道包括：SocketChannel、ServerSocketChannel和DatagramChannel。

SocketChannel是一个连接到TCP网络套接字的通道。可以通过2种方式创建：

1) 打开一个SocketChannel并连接到互联网上的某台服务器。

2) 一个新连接到达ServerSocketChannel时创建一个SocketChannel。

ServerSocketChannel通过ServerSocketChannel.accept() 方法监听新进来的连接。当 accept()方法返回的时候，它返回一个包含新进来的连接的 SocketChannel。因此，accept()方法会一直阻塞到有新连接到达。DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。

将套接字通道和Selector结合，因为选择器的多路复用特性(事件驱动)和套接字通道的非阻塞特性，可有效地解决高并发环境下对于客户端请求处理会耗费大量线程资源的情况。

（1）传统的同步阻塞式IO(网络套接字编程Socket)：针对客户端的每一个请求的连接，都需要分配一个单独的线程进行处理，因为要随时监视其是否有数据读写，而且在数据读写操作时，因为是阻塞式的，所以即使没有数据到来，也会一直阻塞等待。这显然会浪费大量CPU和线程资源。

（2）而多路复用的选择器和非阻塞式的套接字通道的结合：不但可以用一个线程来监视多个与客户端建立的网络连接，还能够在读写数据时，一旦数据没有准备好，就立刻返回而不会阻塞(虽然实际上一旦执行读写是一般数据都已经准备好)。所以在并发较高的场景下，这种方式大大节约了CPU和线程(内存)资源。具体可以参考我这篇文章。

 

参考资料：

1 http://www.iteye.com/magazines/132-Java-NIO

2 http://www.cnblogs.com/dolphin0520/p/3919162.html

3 http://tutorials.jenkov.com/java-nio/nio-vs-io.html