Java NIO的核心组件简介和使用

图片来自nidan-455298会员

在Java Socket通信中,Java NIO是一个很重要的底层实现类,理解其核心组件和使用方法,将会帮助了解更多在Java NIO基础之上搭建的其它Socket通信应用,例如Netty IO等。

本文将对Java NIO 核心组件做一个简单介绍,读完本文,你将可以读Java NIO有个总体上的认识,并能够通过代码样例,编程实现一个多线程异步消息通信。

1. Java NIO概览

Java NIO全称是Java New Input/Output,是很早在JDK1.4中引入的输入输出类库,之后在JDK7中提供了升级版的NIO2,提供了异步编程模型的IO操作。下文若没有说明,Java NIO是指在JDK7之后的最新NIO类库。

有一个首先需要了解的问题是,为什么会有NIO?和之前的IO类库相比,其带来了哪些优点和改进?

在JDK1.4之前,所有IO操作都是基于流(stream)进行数据读写,其读写操作方法会阻塞,这将大大影响程序的效率。Java NIO一方面解决了阻塞的问题,另一方面对数据块存储、数据处理方面进行了抽象,提供了缓存区、通信通道和选择器三个组件概念,使得程序开发者可以在更深入的层次上介入IO处理过程,对相关的通信进行多线程优化,编程可扩展性大大提高。

下表列出IO和NIO在主要特性上的区别对比,

IO NIO
操作对象 面向流 面向缓存区
操作特性 单向操作,或读,或写 支持读写双向操作
读写单位 按字节一一进行读/写 Bytes 按指定块存储大小进行读/写 Block Buffer
支持非阻塞 只支持阻塞读写 支持阻塞和非阻塞读写
通信通道 无,一个流本身就是一个通道 基于通道进行数据传输
单线程 多通道 不支持 支持,通过选择器实现一个线程处理多个通道
异步编程 不支持 支持异步编程模型(自JDK7)

可以看到Java NIO在IO操作上进行了很大幅度的改进和提升。

在Java NIO类库中,有四个核心组件接口,

  1. Channel通道
  2. Buffer缓存区
  3. Selector 选择器
  4. CompletionHandler 异步回调处理器

本文将对这四个组件逐一进行讲解,了解其作用和使用方法,并提供简单的代码使用样例。最后给出一个多线程异步通信的使用样例。

2. 通道Channel

一个通道是数据传输的连接,可以和IO设备建立连接,进行数据的获取和传送。在一定程度上,可以认为通道是流的升级版实现。

整个Java NIO中最常用的通道类有如下几个,

  • FileChannel,since 1.4
  • DatagramChannel,since 1.4
  • SocketChannel,since 1.4
  • ServerSocketChannel,since 1.4
  • AsynchronousFileChannel,since 1.7
  • AsynchronousSocketChannel,since 1.7
  • AsynchronousServerSocketChannel,since 1.7

其中Asynchronous*这几个类是在JDK7开始提供的NIO 2.0类库,主要提供了异步编程模型,详细见后面异步回调处理器的讨论。

(注:AsynchronousDatagramChannel在JDK7中并没有提供,原先是有准备发布这个类库的,但是由于某些原因,在发布前被删除。)

通道类中使用最多的四个方法是,

  • Channel.bind() 绑定连接
  • Channel.accept() 建立连接
  • Channel.read(buffer) 把数据从缓冲区读到通道
  • Channel.write(buffer) 把数据从通道写到缓冲区

一个简单的代码样例如下,

// please note: configure channel blocking state as false
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);

System.out.println("A server is started on port 9000");
ServerSocket serverSocket = server.socket();
serverSocket.bind(new InetSocketAddress(9000));

// please note: server.accept() will not block current thread
// Accept method will return null directly if no client is connected
SocketChannel channel = null;
int count = 0;
while (channel == null) {
    System.out.println("The server is trying to connect client, count=" + count++);
    channel = server.accept();
    Thread.sleep(500);
}
//channel.read(ByteBuffer)

System.out.println("the end");
channel.close();
server.close();

3. 缓冲区Buffer

Java NIO是基于块进行IO操作,缓冲区就是对这个块的抽象定义,在这个缓冲区中可以反复进行读写,通过通道实现数据的传输。

我们先看看缓冲区是什么样子,一个缓冲区是一个有指定大小的数组,其有读模式和写模式两种状态,请注意在读写不同模式下其Position和Limit的位置指向,

上图的缓冲区中显示了如下三个属性,

  • Capacity:缓冲区容量大小
  • Position:缓冲区的读写位置,根据当前读/写模式,含义如下
    • 在读模式下,读的当前位置
    • 在写模式下,写的当前位置
  • Limit:缓冲区的读写限制位,根据当前读/写模式,含义如下
    • 在读模式下,可以读的最大位置,等于当前缓冲区内数据量,防止读溢出
    • 在写模式下,可以写的最大位置,其实就等于Capacity值,防止写溢出

Java NIO提供如下7个缓冲区类,

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

这几个缓冲类基本覆盖了Java中8个基本数据类型的7个,还有一个boolean没有支持,原因是Java的boolean使用1bit进行存储,而在IO操作中,最小单位是bytes。

缓冲区类中使用最多的几个方法是,

  • Buffer.allocate(size) 创建一个指定大小的空缓冲区
  • Buffer.wrap(array) 通过一个数组创建一个缓冲区
  • Buffer.put() 保存一个数据
  • Buffer.flip() 切换写模式到读模式,
  • Buffer.get() 读取一个数据
  • Buffer.clear() 清空缓冲区

一个简单的代码样例如下,

IntBuffer buffer = IntBuffer.allocate(10);  // #1

System.out.println("write 5 int number into buffer");
for (int i = 0; i < 6; i++) {
    buffer.put(i);                          // #2
}

buffer.flip();                              // #3

for (int i = 0; i < 6; i++) {
    int n = buffer.get();                   // #4
    System.out.println("read number: " + n);
}

buffer.clear();                             // #5

结合样例代码,我们对缓冲区的操作流程描绘成下图,以助理解,

各个步骤的说明,

  1. 第一步:初始化一个整型缓冲区,大小为10
  2. 第二步:写入5个整型值到缓冲区
  3. 第三步:切换写模式到读模式
  4. 第四步:从缓冲区读取5个整型值
  5. 第五步:重置整型缓冲区,可以进行下一步的写操作

4. 选择器Selector

选择器能够同时监控多个通道的通信情况,方便多线程处理通道事件。开发者可以通过选择器为如下四个通道状态进行监听,

  • Connect:一个客户端通道已经准备好了连接远程服务器
  • Accept:一个服务器通道已经准备连接客户端,请
  • Read:一个通道已经准备好了读操作
  • Write:一个通道已经准备好了写操作

上述各个通道状态对应的SelectionKey事件为,

  • SelectionKey.OP_CONNECT
  • SelectionKey.OP_ACCEPT
  • SelectionKey.OP_READ
  • SelectionKey.OP_WRITE

需要注意的是,只有通道设置为非阻塞(non-blocking),才能注册到选择器,否则注册时会收到一个IllegalBlockingModeException的异常。

对选择器的通用操作流程为,

  • 创建一个选择器Selector selector=Selector.open()
  • 注册通道channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE)
  • 获取事件key = selector.select()

一个简单的代码样例如下,

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

while(true) {
  int readyChannels = selector.select();
  if(readyChannels == 0) continue;

  Set<SelectionKey> selectedKeys = selector.selectedKeys();
  Iterator<SelectionKey> 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
    }

    keyIterator.remove();
  }
}

5. 异步回调处理器CompletionHandler

异步回调处理器是在JDK 7之后属于Java NIO 2的异步通信组件之一,它提供一种回调机制,让在通信完成之后异步执行通信结果的处理。CompletionHandler本身是一个接口定义,我们先看看这个接口提供的两个回调方法,

public interface CompletionHandler<V,A> {
  void completed(V result, A attachment);
  void failed(Throwable exc, A attachment);
}

接口的两个回调方法,
1. completed() 当操作成功时调用,返回结果
2. failed() 当操作失败时调用,返回异常信息

在我们看如何使用异步回调处理器之前,我们先了解下为什么要异步回调。

前面讲到,我们知道IO操作是一个耗时的操作,于是在Java NIO编程中提供了非阻塞编程模型,使得在执行通信连接、读、写操作时,当前线程并不会挂起等待,

  • Channel.configureBlocking(false);
  • Channel.accept()
  • Channel.read()
  • Channel.write()

非阻塞的执行方式提高了IO操作线程的效率,通过非阻塞,使得当前线程不会没事也被长时间挂起,为当前线程的处理提供了灵活编程空间。但是仔细观察会发现,为了获取某个事件,在程序中会不得不启动一个循环线程,定时的检查连接情况、是否有数据到达等等。下面是两段循环线程的代码样例,

while (channel == null) {
    channel = server.accept();            // #1
    Thread.sleep(500);
}

while(true) {
  int readyChannels = selector.select();  // #2
  if(readyChannels == 0) continue;
  // read the event keys
  Set<SelectionKey> selectedKeys = selector.selectedKeys();
}

第一个:通过定时查询Channel的连接状态
第二个:通过选择器Selector查询Channel的连接和数据读写状态

这种循环线程若配合多线程处理,可以达到非常强大的效果,一个参考实现见后面提供的“非阻塞通信-多子线程异步处理”代码样例,实践过程中也多采用这种方式,通过ServerSocketChannel + Selector + Buffer实现“非阻塞通信-多子线程异步处理”。

但有没有一个办法,使得不再需要起一个循环线程?答案有,在JDK7 NIO 2中引入的三个异步通信通道就实现了这样的需求,

  • AsynchronousFileChannel,since 1.7
  • AsynchronousSocketChannel,since 1.7
  • AsynchronousServerSocketChannel,since 1.7

上述几个异步通信通道在accept/read/write方法上,需要接受一个CompletionHandler回调对象。(注:异步通信通道还可以通过Future方式进行回调,本文为了更好地描述异步实现方式,将不对Future方式进行展开。)

这就是异步回调处理器是作为Java NIO 2的异步通信组件之一,配合异步通信通道实现异步处理机制。异步通信通道执行accept/read/write完毕后,JVM将会启动子线程,根据执行结果,若成功完成就调用对应的回调对象的completed方法,若失败则调用failed方法。

异步回调处理器解决了循环线程检查的问题,但随之而来就是出现各种嵌套回调,大大增加软件编程的复杂度。鱼和熊掌,不可兼得。

下面是一个简单的代码样例,

public static void main(String[] args) throws Exception {
    AsynchronousServerSocketChannel server =
          AsynchronousServerSocketChannel.open();
    server = server.bind(new InetSocketAddress(9000));

   OnAcceptCompletionHandler onAcceptCompletion =
          new OnAcceptCompletionHandler();
    server.accept(null, onAcceptCompletion);

    // app continue to run...
Thread.sleep(100000);
    server.close();
}

public static class OnAcceptCompletionHandler implements
              CompletionHandler<AsynchronousSocketChannel, Object> {
    @Override
    public void completed(AsynchronousSocketChannel srv, Object attachment) {
        System.out.println("Received a new client connection.");
        //srv.read(buffer...)
    }

    @Override
    public void failed(Throwable exc, Object attachment) {
        System.out.println("Received a failure message on client connection.");
    }
}

6. 多线程异步消息通信

为了更加深入的理解Java NIO通信类库,请点击这里查看一个多线程异步消息通信的简单实现。

在代码中实现了如下的消息通信流程,

在ServerSocketChannel通道有消息时,通过线程池启动异步线程处理消息。测试时,可以使用命令telnet localhost 9000同时启动多个客户端和服务端连接,查看消息通信情况。

7. 更多样例:使用Java NIO进行Socket通信

下面提供各种应用样例,实现从阻塞通信、非阻塞通信,到多线程通信、异步通信的各个实现方法,可供参考和调研时使用,

  1. 阻塞通信,通过ServerSocket,请点击这里查看代码。
  2. 阻塞通信,通过ServerSocketChannel,请点击这里查看代码。
  3. 非阻塞通信,通过ServerSocketChannel,请点击这里查看代码。
  4. 非阻塞通信-主线程处理,通过ServerSocketChannel + Selector + Buffer,请点击这里查看代码。
  5. 非阻塞通信-多子线程处理,通过ServerSocketChannel + Selector + Buffer,请点击这里查看代码。
  6. 非阻塞通信-多子线程异步处理,通过ServerSocketChannel + Selector + Buffer,请点击这里查看代码。
  7. 异步通信,通过AsynchronousServerSocketChannel + CompletionHandler,请点击这里查看代码。

上述样例在JDK 8中编译运行通过,并使用Windows 7 SP1 x64的Telnet工具、使用Ubuntu 16.10中的Telnet工具进行测试通信验证。

可以使用如下方法来运行样例和查看通信过程,

  1. 启动通信服务端,样例中所有通信服务端将启动在9000端口
  2. 使用Telnet工具
    • 在Windows的Shell命令行中,执行telnet 127.0.0.1 9000命令,连接服务端。成功后,按ctrl+ }键退出telnet交互,然后可以通过send hello,world命令发送消息到服务端。若想关闭连接,可以通过close命令关闭连接。更多telnet详细命令见help。
    • 在Linux的Shell命令行中,执行telnet 127.0.0.1 9000命令,连接服务端。成功后,然后可以通过输入hello,world字符,按回车键发送消息到服务端。若想关闭连接,按ctrl+ }键退出telnet交互,然后可以通过close命令关闭连接。更多telnet详细命令见help。
  3. 启动通信客户端
    • 查看客户端消息
    • 查看服务端接受消息

8. 本文讨论的概念和范围

在本文中提及了阻塞、非阻塞、异步的这三个概念,为了避免歧义,这里有必要对三个概念进行描述,这个描述主要针对其在本文中的定义,以助理解,

  • 阻塞:在执行通信的连接、读操作、写操作时,若对方无响应,则当前线程会被挂起
  • 非阻塞:在执行通信的连接、读操作、写操作时,若对方无响应,当前线程不会被挂起
  • 异步:在执行通信的连接、读操作、写操作时,当前线程的执行不受其影响,当通信操作结束后,JVM会启动子线程以异步回调的方式处理通信结果。

上面的阻塞和非阻塞主要是从是否挂起线程的角度来判断。

本文讨论Java NIO的通信过程,讨论范围主要是Java应用程序和JVM之间的交互,

对于JDK/JVM和各个操作系统内核的IO通信交互实现,将需要另外一篇文章进行深入讨论,这将会涉及到JDK IO的更底层实现细节,也需要对各个操作系统的IO操作进行深入的了解。

9. 参考资料

  1. Java NIO Tutorial,作者Jakob Jenkov
  2. IBM DeveloperWorks – NIO入门
  3. IBM DeveloperWorks – NIO 2.0入门
  4. JDK-6993126 : (aio) remove AsynchronousDatagramChannel

读李笑来的《财富自由之路》

李笑来 著

昨天拿起李笑来的《财富自由之路》一书,一口气读完,对里面讲的一些内容深有体会。人生其实很短暂,三年一个时代,十二年一个轮回,每个人都有机会在自己的财富自由之路上走地更远,问题是你愿不愿意?

财富

什么是财富?钱、黄金、房子,或者其它。我们的财富难道就这些么?我们的自由、我们的时间、我们的思考、我们的家人,难道不是我们的财富么?我们的财富确实很多,但我们花了多少时间去了解这些财富,怎样才能让我们的财富富有起来,我们又是怎样花销掉这些财富的。当我们慢慢去思考这些问题的时候,我们会发现,原来我们是这样愚钝、奢侈和浪费。

有几个财富,是有理由让我们需要知道的,
- 时间
- 注意力
- 思考

时间

上帝在创造人的时候,给了每个人最公平的事情是,我们每个人的每天时间都是一样的,24小时,不多一分,也不多一秒。如果我们每个人都是用时间来创造价值的话,我们都在做一种交换,以时间交换我们想要的东西,这是一种交易。

世界上的人,按对时间的交换方式,大概可以划分如下三类商业模式进行赚钱,

  1. 卖自己的一份时间
  2. 把自己的一份时间卖出多份
  3. 买别人的时间,成为自己的时间

第一种是方式应该很熟悉,我们上班工作时,把自己一天8小时的时间卖给公司,赚取薪水。一天24小时,勤奋点,可以卖个18小时,然后睡6小时,这已经是极限。这种方式是积累财富最简单的方式,它不可耻,劳动光荣,而且这是我们成长的必经之路。这是大多数人出售自己时间的方式,但很大的问题是,在劳动的同时,你是否有成长。

第二种方式比第一种高级一些,我们一天确实只有24小时,但我们有没有办法把它卖出多份?这种方式确实有,写书就是一种,各种知识产权的也是,软件开发也是,工厂的模具设计也是,当花个1个小时写一篇文章,花一天设计开发一个软件,虽然刚开始要花些时间,但接下来可以批量复制、批量执行,不断卖出多份。这种方式易懂,但不易学,将时间卖出多份还需要一定的智慧。

第三种方式属于做老板们,购买别人的时间,为自己做事。不是每个人都适合成为老板。

时间是宝贵的,一份耕耘,一份收获,你愿意将时间投入到哪里,哪里就会有你的产出。

注意力

李笑来在书中谈到,什么是我们每个人的最宝贵财富?

很多人觉得是时间,但是仔细思考,会发现时间不受我们控制,我们无法创造它,也无法抛弃,你不用它,它就从你身边流过。还是一句话,上帝是公平的,一天24小时,每个人不会多一分,也不会少一秒。

那什么是我们能拥有的最宝贵财富?答案:注意力。李笑来在书中对其的定义,
- 注意力是你唯一可以随意调用且能有所产出的资源

若你将注意力放在学习上,你有所进步;若将注意力放在思考上,你将提升你的认知;若你将注意力放在没有任何产出的地方,那你就惨了,你将没有任何成长。

非常可惜的是,我们都在挥霍我们的注意力,莫名其妙凑热闹,心急火燎随大流,为别人操碎了心,刷微信朋友圈,追娱乐明星新闻,看连播电视剧。我们的注意力就这样被消费了,被别人消费了!没有一件事会带来你财富的成长,或者说,你的成长。

把注意力、时间、金钱的重要性进行比较,从高到低,

注意力》时间》金钱

你的注意力比时间更重要,你的时间比金钱更重要。这样相比之下,你会发现,你的金钱是最便宜的。

思考

在人类的进化史上,猿人和动物的区别,在于猿人会制造和使用工具,人和猿人的区别在于,人会使用文字和语言。现在的人作为高级动物,都有思考的能力,但是否愿意思考,却不是每个人能做的到、做的好。

思考是一个人自我进化的关键方式,若将我们自己的脑袋思维比喻为一个操作系统,那么思考就是这个操作系统更新升级的方式。

人一生中,会不断形成自己的思维,这个思维因人而异。最开始的是上学的时候获取对这个世界的认识,毕业后则根据社会历练,不断的变化着自己的思维。在这个过程中,你有没有过认真地对某个问题进行详细深入的思考?甚至一遍又一遍的思考。有些人的思考是被动的,碰到问题才思考,好听点叫逢山开路、遇水搭桥,难听点叫随波逐流、穷则思变。思考本身是一个主动的行为,但大多数的时候,和对注意力一样,我们也放弃了自己的主观能动性。

学会思考,不断地为我们的思维更新换代。

成长

一夜暴富的新闻故事,每天拨动着人们的心弦,每个人在想,要是那个暴富的人是我会怎样?于是彩票、赌博屡禁不止。

实际上的一个人的成长是怎样的?请看一个指数曲线,

上面的指数曲线说明这样的问题,一个人的成长,在很长的时间内,看不出太大的变化,但是一旦到了拐点后,其成长将会迅速升高,未来变得无限可能。

想要有这个的成长曲线,问题是,你每天有成长么?

书籍:财富自由之路
作者:李笑来,ISBN 9787121320088
评分:4分,推荐阅读,评分详细说明见这里。