Java 深度历险（八）——Java I/O

在应用程序中，通常会涉及到两种类型的计算：CPU 计算和 I/O 计算。对于大多数应用来说，花费在等待 I/O 上的时间是占较大比重的。通常需要等待速度较慢的磁盘或是网络连接完成 I/O 请求，才能继续后面的 CPU 计算任务。因此提高 I/O 操作的效率对应用的性能有较大的帮助。本文将介绍 Java 语言中与 I/O 操作相关的内容，包括基本的 Java I/O 和 Java NIO，着重于基本概念和最佳实践。

流

Java 语言提供了多个层次不同的概念来对 I/O 操作进行抽象。Java I/O 中最早的概念是流，包括输入流和输出流，早在 JDK 1.0 中就存在了。简单的来说，流是一个连续的字节的序列。输入流是用来读取这个序列，而输出流则构建这个序列。 InputStream 和 OutputStream 所操纵的基本单元就是字节。每次读取和写入单个字节或是字节数组。如果从字节的层次来处理数据类型的话，操作会非常繁琐。可以用更易使用的流实现来包装基本的字节流。如果想读取或输出 Java 的基本数据类型，可以使用 DataInputStream 和 DataOutputStream 。它们所提供的类似 readFloat 和 writeDouble 这样的方法，会让处理基本数据类型变得很简单。如果希望读取或写入的是 Java 中的对象的话，可以使用 ObjectInputStream 和 ObjectOutputStream 。它们与对象的序列化机制一起，可以实现Java 对象状态的持久化和数据传递。基本流所提供的对于输入和输出的控制比较弱。InputStream 只提供了顺序读取、跳过部分字节和标记/ 重置的支持，而OutputStream 则只能顺序输出。

流的使用

由于I/O 操作所对应的实体在系统中都是有限的资源，需要妥善的进行管理。每个打开的流都需要被正确的关闭以释放资源。所遵循的原则是谁打开谁释放。如果一个流只在某个方法体内使用，则通过finally 语句或是JDK 7 中的 try-with-resources 语句来确保在方法返回之前，流被正确的关闭。如果一个方法只是作为流的使用者，就不需要考虑流的关闭问题。典型的情况是在 servlet 实现中并不需要关闭 HttpServletResponse 中的输出流。如果你的代码需要负责打开一个流，并且需要在不同的对象之间进行传递的话，可以考虑使用 Execute Around Method 模式。如下面的代码所示：

 
public void use(StreamUser user) {
   InputStream input = null;
   try {
       input = open();
       user.use(input);
   } catch(IOException e) {
       user.onError(e);
   } finally {
       if (input != null) {
           try { 
               input.close();
           } catch (IOException e) {
               user.onError(e);
           }
       }
   }
} 

如上述代码中所看到的一样，由专门的类负责流的打开和关闭。流的使用者 StreamUser 并不需要关心资源释放的细节，只需要对流进行操作即可。

在使用输入流的过程中，经常会遇到需要复用一个输入流的情况，即多次读取一个输入流中的内容。比如通过 URL.openConnection 方法打开了一个远端站点连接的输入流，希望对其中的内容进行多次处理。这就需要把一个 InputStream 对象在多个对象中传递。为了保证每个使用流的对象都能获取到正确的内容，需要对流进行一定的处理。通常有两种解决的办法，一种是利用 InputStream 的标记支持。如果一个流支持标记的话（通过 markSupported 方法判断），就可以在流开始的地方通过 mark 方法添加一个标记，当完成一次对流的使用之后，通过 reset 方法就可以把流的读取位置重置到上次标记的位置，即流开始的地方。如此反复，就可以复用这个输入流。大部分输入流的实现是不支持标记的。可以通过 BufferedInputStream 进行包装来支持标记。

 
private InputStream prepareStream(InputStream ins) {
   BufferedInputStream buffered = new BufferedInputStream(ins);
   buffered.mark(Integer.MAX_VALUE);
   return buffered;
} 
private void resetStream(InputStream ins) throws IOException {
   ins.reset();
   ins.mark(Integer.MAX_VALUE);
}  

如上面的代码所示，通过 prepareStream 方法可以用一个 BufferedInputStream 来包装基本的 InputStream。通过 mark 方法在流开始的时候添加一个标记，允许读入 Integer.MAX_VALUE 个字节。每次流使用完成之后，通过 resetStream 方法重置即可。

另外一种做法是把输入流的内容转换成字节数组，进而转换成输入流的另外一个实现 ByteArrayInputStream 。这样做的好处是使用字节数组作为参数传递的格式要比输入流简单很多，可以不需要考虑资源相关的问题。另外也可以尽早的关闭原始的输入流，而无需等待所有使用流的操作完成。这两种做法的思路其实是相似的。BufferedInputStream 在内部也创建了一个字节数组来保存从原始输入流中读入的内容。

 
private byte[] saveStream(InputStream input) throws IOException {
   ByteBuffer buffer = ByteBuffer.allocate(1024);
   ReadableByteChannel readChannel = Channels.newChannel(input);
   ByteArrayOutputStream output = new ByteArrayOutputStream(32 * 1024);
   WritableByteChannel writeChannel = Channels.newChannel(output);
   while ((readChannel.read(buffer)) > 0 || buffer.position() != 0) {
       buffer.flip();
       writeChannel.write(buffer);
       buffer.compact();
   }
   return output.toByteArray();
}   

上面的代码中 saveStream 方法把一个 InputStream 保存为字节数组。

缓冲区

由于流背后的数据有可能比较大，在实际的操作中，通常会使用缓冲区来提高性能。传统的缓冲区的实现是使用数组来完成。比如经典的从 InputStream 到 OutputStream 的复制的实现，就是使用一个字节数组作为中间的缓冲区。NIO 中引入的 Buffer 类及其子类，可以很方便的用来创建各种基本数据类型的缓冲区。相对于数组而言，Buffer 类及其子类提供了更加丰富的方法来对其中的数据进行操作。后面会提到的通道也使用 Buffer 类进行数据传递。

在 Buffer 上进行的元素添加和删除操作，都围绕 3 个属性 position 、 limit 和 capacity 展开，分别表示 Buffer 当前的读写位置、可用的读写范围和容量限制。容量限制是在创建的时候指定的。Buffer 提供的 get/put 方法都有相对和绝对两种形式。相对读写时的位置是相对于 position 的值，而绝对读写则需要指定起始的序号。在使用 Buffer 的常见错误就是在读写操作时没有考虑到这 3 个元素的值，因为大多数时候都是使用的是相对读写操作，而 position 的值可能早就发生了变化。一些应该注意的地方包括：将数据读入缓冲区之前，需要调用 clear 方法；将缓冲区中的数据输出之前，需要调用 flip 方法。

 
ByteBuffer buffer = ByteBuffer.allocate(32);
CharBuffer charBuffer = buffer.asCharBuffer();
String content = charBuffer.put("Hello ").put("World").flip().toString();
System.out.println(content);  

上面的代码展示了 Buffer 子类的使用。首先可以在已有的 ByteBuffer 上面创建出其它数据类型的缓冲区视图，其次 Buffer 子类的很多方法是可以级联的，最后是要注意 flip 方法的使用。

字符与编码

在程序中，总是免不了与字符打交道，毕竟字符是用户直接可见的信息。而与字符处理直接相关的就是编码。相信不少人都曾经为了程序中的乱码问题而困扰。要弄清楚这个问题，就需要理解字符集和编码的概念。字符集，顾名思义，就是字符的集合。一个字符集中所包含的字符通常与地区和语言有关。字符集中的每个字符通常会有一个整数编码与其对应。常见的字符集有 ASCII、ISO-8859-1 和 Unicode 等。对于字符集中的每个字符，为了在计算机中表示，都需要转换某种字节的序列，即该字符的编码。同一个字符集可以有不同的编码方式。如果某种编码格式产生的字节序列，用另外一种编码格式来解码的话，就可能会得到错误的字符，从而产生乱码的情况。所以将一个字节序列转换成字符串的时候，需要知道正确的编码格式。

NIO 中的 java.nio.charset 包提供了与字符集相关的类，可以用来进行编码和解码。其中的 CharsetEncoder 和 CharsetDecoder 允许对编码和解码过程进行精细的控制，如处理非法的输入以及字符集中无法识别的字符等。通过这两个类可以实现字符内容的过滤。比如应用程序在设计的时候就只支持某种字符集，如果用户输入了其它字符集中的内容，在界面显示的时候就是乱码。对于这种情况，可以在解码的时候忽略掉无法识别的内容。

 
String input = " 你 123 好 ";
Charset charset = Charset.forName("ISO-8859-1");
CharsetEncoder encoder = charset.newEncoder();
encoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
CharsetDecoder decoder = charset.newDecoder();
CharBuffer buffer = CharBuffer.allocate(32);
buffer.put(input);
buffer.flip();
try {
   ByteBuffer byteBuffer = encoder.encode(buffer);
   CharBuffer cbuf = decoder.decode(byteBuffer);
   System.out.println(cbuf);  // 输出 123
} catch (CharacterCodingException e) {
   e.printStackTrace();
}  
 

上面的代码中，通过使用 ISO-8859-1 字符集的编码和解码器，就可以过滤掉字符串中不在此字符集中的字符。

Java I/O 在处理字节流字之外，还提供了处理字符流的类，即 Reader / Writer 类及其子类，它们所操纵的基本单位是 char 类型。在字节和字符之间的桥梁就是编码格式。通过编码器来完成这两者之间的转换。在创建 Reader/Writer 子类实例的时候，总是应该使用两个参数的构造方法，即显式指定使用的字符集或编码解码器。如果不显式指定，使用的是 JVM 的默认字符集，有可能在其它平台上产生错误。

通道

通道作为 NIO 中的核心概念，在设计上比之前的流要好不少。通道相关的很多实现都是接口而不是抽象类。通道本身的抽象层次也更加合理。通道表示的是对支持 I/O 操作的实体的一个连接。一旦通道被打开之后，就可以执行读取和写入操作，而不需要像流那样由输入流或输出流来分别进行处理。与流相比，通道的操作使用的是 Buffer 而不是数组，使用更加方便灵活。通道的引入提升了 I/O 操作的灵活性和性能，主要体现在文件操作和网络操作上。

文件通道

对文件操作方面，文件通道 FileChannel 提供了与其它通道之间高效传输数据的能力，比传统的基于流和字节数组作为缓冲区的做法，要来得简单和快速。比如下面的把一个网页的内容保存到本地文件的实现。

 
FileOutputStream output = new FileOutputStream("baidu.txt");
FileChannel channel = output.getChannel();
URL url = new URL("http://www.baidu.com");
InputStream input = url.openStream();
ReadableByteChannel readChannel = Channels.newChannel(input);
channel.transferFrom(readChannel, 0, Integer.MAX_VALUE);   

文件通道的另外一个功能是对文件的部分片段进行加锁。当在一个文件上的某个片段加上了排它锁之后，其它进程必须等待这个锁释放之后，才能访问该文件的这个片段。文件通道上的锁是由 JVM 所持有的，因此适合于与其它应用程序协同时使用。比如当多个应用程序共享某个配置文件的时候，如果 Java 程序需要更新此文件，则可以首先获取该文件上的一个排它锁，接着进行更新操作，再释放锁即可。这样可以保证文件更新过程中不会受到其它程序的影响。

另外一个在性能方面有很大提升的功能是内存映射文件的支持。通过FileChannel 的 map 方法可以创建出一个 MappedByteBuffer 对象，对这个缓冲区的操作都会直接反映到文件内容上。这点尤其适合对大文件进行读写操作。

套接字通道

在套接字通道方面的改进是提供了对非阻塞 I/O 和多路复用 I/O 的支持。传统的流的 I/O 操作是阻塞式的。在进行 I/O 操作的时候，线程会处于阻塞状态等待操作完成。NIO 中引入了非阻塞 I/O 的支持，不过只限于套接字 I/O 操作。所有继承自 SelectableChannel 的通道类都可以通过 configureBlocking 方法来设置是否采用非阻塞模式。在非阻塞模式下，程序可以在适当的时候查询是否有数据可供读取。一般是通过定期的轮询来实现的。

多路复用 I/O 是一种新的 I/O 编程模型。传统的套接字服务器的处理方式是对于每一个客户端套接字连接，都新创建一个线程来进行处理。创建线程是很耗时的操作，而有的实现会采用线程池。不过一个请求一个线程的处理模型并不是很理想。原因在于耗费时间创建的线程，在大部分时间可能处于等待的状态。而多路复用 I/O 的基本做法是由一个线程来管理多个套接字连接。该线程会负责根据连接的状态，来进行相应的处理。多路复用 I/O 依靠操作系统提供的 select 或相似系统调用的支持，选择那些已经就绪的套接字连接来处理。可以把多个非阻塞 I/O 通道注册在某个 Selector 上，并声明所感兴趣的操作类型。每次调用 Selector 的 select 方法，就可以选择到某些感兴趣的操作已经就绪的通道的集合，从而可以进行相应的处理。如果要执行的处理比较复杂，可以把处理转发给其它的线程来执行。

下面是一个简单的使用多路复用 I/O 的服务器实现。当有客户端连接上的时候，服务器会返回一个 Hello World 作为响应。

 
private static class IOWorker implements Runnable {
   public void run() {
       try {
           Selector selector = Selector.open();
           ServerSocketChannel channel = ServerSocketChannel.open();
           channel.configureBlocking(false);
           ServerSocket socket = channel.socket();
           socket.bind(new InetSocketAddress("localhost", 10800));
           channel.register(selector, channel.validOps());
           while (true) {
               selector.select();
               Iterator<selectionkey> iterator = selector.selectedKeys().iterator();<br></br>                while (iterator.hasNext()) {<br></br>                    SelectionKey key = iterator.next();<br></br>                    iterator.remove();<br></br>                    if (!key.isValid()) {<br></br>                        continue;<br></br>                    }<br></br>                    if (key.isAcceptable()) {<br></br>                        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();<br></br>                        SocketChannel sc = ssc.accept();<br></br>                        sc.configureBlocking(false);<br></br>                        sc.register(selector, sc.validOps()); <br></br>                    }<br></br>                    if (key.isWritable()) {<br></br>                        SocketChannel client = (SocketChannel) key.channel();<br></br>                        Charset charset = Charset.forName("UTF-8");<br></br>                        CharsetEncoder encoder = charset.newEncoder();<br></br>                        CharBuffer charBuffer = CharBuffer.allocate(32);<br></br>                        charBuffer.put("Hello World");<br></br>                        charBuffer.flip();<br></br>                        ByteBuffer content = encoder.encode(charBuffer);<br></br>                        client.write(content);<br></br>                        key.cancel();<br></br>                    }<br></br>                }<br></br>            }<br></br>        } catch (IOException e) {<br></br>            e.printStackTrace();<br></br>        }<br></br>    }<br></br>}<br></br></selectionkey>

上面的代码给出的只是非常简单的示例程序，只是展示了多路复用 I/O 的基本使用方式。在开发复杂网络应用程序的时候，使用一些 Java NIO 网络应用框架会让你事半功倍。目前来说最流行的两个框架是 Apache MINA 和 Netty 。在使用了 Netty 之后，Twitter 的搜索功能速度提升达到了 3 倍之多。网络应用开发人员都可以使用这两个开源的优秀框架。

参考资料

• Java 6 I/O-related APIs & Developer Guides
• Top Ten New Things You Can Do with NIO
• Building Highly Scalable Servers with Java NIO

感谢张凯峰对本文的策划和审校。

给InfoQ 中文站投稿或者参与内容翻译工作，请邮件至 editors@cn.infoq.com 。也欢迎大家加入到 InfoQ 中文站用户讨论组中与我们的编辑和其他读者朋友交流。