您的位置 首页 java

快速弄懂Java 11 中的NIO 2.0

NIO2.0时代

1. 变更通知(因为每个事件都需要一个监听者)

对NIO和NIO.2有兴趣的开发者的共同关注点在于 Java 应用的性能。根据我的经验,NIO.2里的文件变更通知者(file change notifier)是新输入/输出API里最让人感兴趣(被低估了)的特性。

很多企业级应用需要在下面的情况时做一些特殊的处理:

  • 当一个文件上传到一个FTP文件夹里时
  • 当一个配置里的定义被修改时
  • 当一个草稿文档被上传时
  • 其他的文件系统事件出现时

这些都是变更通知或者变更响应的例子。在Java(以及其他语言)的早期版本里, 轮询 (polling)是检测这些变更事件的最好方式。轮询是一种特殊的无限循环:检查文件系统或者其他对象,并且和之前的状态对比,如果没有变化,在大概几百个毫秒或者10秒的间隔后,继续检查。就这一直无限循环下去。

NIO.2提供了一个更好地方式来进行变更检测。列表1是一个简单的示例。

列表1. NIO.2里的变更通知机制

public class Watcher { 
 public static void main(String[] args) { 
 Path this_dir = Paths.get("."); 
 System.out.println("Now watching the current directory ..."); 
 
 try { 
 WatchService watcher = this_dir.getFileSystem().newWatchService(); 
 this_dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE); 
 
 WatchKey watckKey = watcher.take(); 
 
 List<WatchEvent<<64;>> events = watckKey.pollEvents(); 
 for (WatchEvent event : events) { 
 System.out.println("Someone just created the file '" + event.context().toString() + "'."); 
 
 } 
 
 } catch (Exception e) { 
 System.out.println("Error: " + e.toString()); 
 } 
 } 
 }
 

编译这段代码,然后在命令行里执行。在相同的目录下,创建一个新的文件,例如运行touch example或者copy Watcher.class example命令。你会看到下面的变更通知消息:

这个简单的示例展示了怎么开始使用Java NIO的功能。同时,它也介绍了NIO.2的Watcher类,它相比较原始的I/O中的轮询方案而言,显得更加直接和易用。

注意拼写错误

当你从这篇文章里拷贝代码时,注意拼写错误。例如,列表1种的StandardWatchEventKinds 对象是复数的形式。即使在Java.net的文档里都把它给拼写错了。

小技巧

NIO里的通知机制比老的轮询方式使用起来更加简单,这样会诱导你忽略对具体需求的详细分析。当你在你第一次使用一个监听器的时候,你需要仔细考虑你所使用的这些概念的语义。例如,知道一个变更什么时候会结束比知道它什么时候开始更加重要。这种分析需要非常仔细,尤其是像移动FTP文件夹这种常见的场景。NIO是一个功能非常强大的包,但同时它还会有一些微妙的“陷阱”,这会给那些不熟悉它的人带来困扰。

2. 选择器和异步IO:通过选择器来提高多路复用

NIO新手一般都把它和“非阻塞输入/输出”联系在一起。NIO不仅仅只是非阻塞I/O,不过这种认知也不完全是错的:Java的基本I/O是阻塞式I/O——意味着它会一直等待到操作完成——然而,非阻塞或者异步I/O是NIO里最常用的一个特点,而非NIO的全部。

NIO的非阻塞I/O是事件驱动的,并且在列表1里文件系统监听示例里进行了展示。这就意味着给一个I/O通道定义一个选择器(回调或者监听器),然后程序可以继续运行。当一个事件发生在这个选择器上时——例如接收到一行输入——选择器会“醒来”并且执行。所有的这些都是通过一个单线程来实现的,这和Java的标准I/O有着显著的差别的。

列表2里展示了使用NIO的选择器实现的一个多端口的网络程序echo-er,这里是修改了Greg Travis在2003年创建的一个小程序(参考资源列表)。Unix和类Unix系统很早就已经实现高效的选择器,它是Java网络高性能编程模型的一个很好的参考模型。

列表2. NIO选择器

 public class MultiPortEcho 
 { 
 private int ports[]; 
 private ByteBuffer echoBuffer = ByteBuffer.allocate( 1024 ); 
 public MultiPortEcho( int ports[] ) throws IOException { 
 this.ports = ports; 
 configure_selector(); 
 } 
 
 private void configure_selector() throws IOException { 
 // Create a new selector 
 Selector selector = Selector.open(); 
 
 // Open a listener on each port, and register each one 
 // with the selector 
 for (int i=0; i<ports.length; ++i) { 
 ServerSocket channel  ssc = ServerSocketChannel.open(); 
 ssc.configureBlocking(false); 
 ServerSocket ss = ssc.socket(); 
 InetSocketAddress address = new InetSocketAddress(ports[i]); 
 ss.bind(address); 
 
 SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT); 
 
 System.out.println("Going to listen on " + ports[i]); 
 } 
 
 while (true) { 
 int num = selector.select(); 
 
 Set selectedKeys = selector.selectedKeys(); 
 Iterator it = selectedKeys.iterator(); 
 
 while (it.hasNext()) { 
 SelectionKey key = (SelectionKey) it.next(); 
 
 if ((key.ready ops () & SelectionKey.OP_ACCEPT) 
 == SelectionKey.OP_ACCEPT) { 
 // Accept the new connection 
 ServerSocketChannel ssc = (ServerSocketChannel)key.channel(); 
 SocketChannel sc = ssc.accept(); 
 sc.configureBlocking(false); 
 
 // Add the new connection to the selector 
 SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ); 
 it.remove(); 
 
 System.out.println( "Got connection from "+sc ); 
 } else if ((key.readyOps() & SelectionKey.OP_READ) 
 == SelectionKey.OP_READ) { 
 // Read the data 
 SocketChannel sc = (SocketChannel)key.channel(); 
 
 // Echo data 
 int bytesEchoed = 0; 
 while (true) { 
 echoBuffer.clear(); 
 
 int number_of_bytes = sc.read(echoBuffer); 
 
 if (number_of_bytes <= 0) { 
 break; 
 } 
 
 echoBuffer.flip(); 
 
 sc.write(echoBuffer); 
 bytesEchoed += number_of_bytes; 
 } 
 
 System.out.println("Echoed " + bytesEchoed + " from " + sc); 
 
 it.remove(); 
 } 
 
 } 
 } 
 } 
 }
 

编译这段代码,然后通过类似于java MultiPortEcho 8005 8006这样的命令来启动它。一旦这个程序运行成功,启动一个简单的telnet或者其他的终端模拟器来连接8005和8006接口。你会看到这个程序会回显它接收到的所有字符——并且它是通过一个Java 线程 来实现的。

java 11的新 Selector 回调方式

public int select(Consumer<SelectionKey> action, long timeout)
 throws IOException
{
 if (timeout < 0)
 throw new IllegalArgumentException("Negative timeout");
 return doSelect(Objects.requireNonNull(action), timeout);
}
 
public int select(Consumer<SelectionKey> action) throws IOException {
 return select(action, 0);
}
 
public int selectNow(Consumer<SelectionKey> action) throws IOException {
 return doSelect(Objects.requireNonNull(action), -1);
}
 

java 11新的 SelectionKey

ops为感兴趣的事件

public int interestOpsOr(int ops) {
  synchronized  (this) {
 int oldVal = interestOps();
 interestOps(oldVal | ops);
 return oldVal;
 }
}
 

ops为感兴趣的事件

public int interestOpsAnd(int ops) {
 synchronized (this) {
 int oldVal = interestOps();
 interestOps(oldVal & ops);
 return oldVal;
 }
}
 

3. 通道:承诺与现实

在NIO里,一个通道(channel)可以表示任何可以读写的对象。它的作用是为文件和套接口提供抽象。NIO通道支持一系列一致的方法,这样就使得 编码 的时候不需要去特别关心不同的对象,无论它是标准输出,网络连接还是正在使用的通道。通道的这个特性是继承自Java基本I/O中的流(stream)。流(stream)提供了阻塞式的IO;通道支持异步I/O。

NIO经常会因为它的性能高而被推荐,不过更准确地是因为它的响应快速。在有些场景下NIO会比基本的Java I/O的性能要差。例如,对于一个小文件的简单的顺序读写,简单通过流来实现的性能可能比对应的面向事件的基于通道的编码实现的快两到三倍。同时,非多路复用(non-multiplex)的通道——也就是每个线程一个单独的通道——要比多个通道把各自的选择器注册在同一个线程里要慢多了。

下面你在考虑是使用流还是通道的时候,试着问自己下面几个问题:

  • 你需要读写多少个I/O对象?
  • 不同的I/O对象直接是否有有顺序,还是他们都需要同时发生的?
  • 你的I/O对象是需要持续一小段时间还是在你的进程的整个声明周期都存在?
  • 你的I/O是适合在单个线程里处理还是在几个不同的线程里?
  • 网络通信和本地I/O是看起来一样,还是各自有着不同的模式?

这样的分析是决定使用流还是通道的一个最佳实践。记住:NIO和NIO.2不是基本I/O的替代,而它的一个补充。

4. 内存映射 ——好钢用在刀刃上

NIO里对性能提升最显著的是内存映射(memory mapping)。内存映射是一个系统层面的服务,它把程序里用到的文件的一段当作内存来处理。

内存映射存在很多潜在的影响,比我这里提供的要多。在一个更高的层次上,它能够使得文件访问的I/O的性能达到内存访问的速度。内存访问的速度往往比文件访问的速度快几个数量级。列表3是一个NIO内存映射的一个简单示例。

列表3. NIO里的内存映射

 public class mem_map_example { 
 private static int mem_map_size = 20 * 1024 * 1024; 
 private static String fn = "example_memory_mapped_file.txt"; 
 
 public static void main(String[] args) throws Exception { 
 RandomAccessFile memoryMappedFile = new RandomAccessFile(fn, "rw"); 
 
 //Mapping a file into memory 
 MappedByteBuffer out = memoryMappedFile.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, mem_map_size); 
 
 //Writing into Memory Mapped File 
 for (int i = 0; i < mem_map_size; i++) { 
 out.put((byte) 'A'); 
 } 
 System.out.println("File '" + fn + "' is now " + Integer.toString(mem_map_size) + " bytes full."); 
 
 // Read from memory-mapped file. 
 for (int i = 0; i < 30 ; i++) { 
 System.out.print((char) out.get(i)); 
 } 
 System.out.println("\nReading from memory-mapped file '" + fn + "' is complete."); 
 } 
 }
 

在列表3中,这个简单的示例创建了一个20M的文件example_memory_mapped_file.txt,并且用字符A对它进行填充,然后读取前30个字节。在实际的应用中,内存映射不仅仅擅长提高I/O的原始速度,同时它也允许多个不同的reader和writer同时处理同一个文件镜像。这个技术功能强大但是也很危险,不过如果正确使用的话,它会使得你的IO速度提高数倍。众所周知,华尔街的交易操作为了能够赢得秒级甚至是毫秒级的优势,都使用了内存映射技术。

5. 字符编码和搜索

我在这篇文章里要讲解的NIO的最后一个特性是charset,一个用来转换不同字符编码的包。在NIO之前,Java通过getByte方法内置实现了大部分相同的功能。charset很受欢迎,因为它比getBytes更加灵活,并且能够在更底层去实现,这样就能够获得更好的性能。这个对于搜索那些对于编码、顺序以及其他语言特点比较敏感的非英语语言而言更加有价值。

列表4展示了一个把Java里的Unicode字符转换成Latin-1的示例

列表4. NIO里的字符

String some_string = "This is a string that Java natively stores as Unicode."; 
 Charset latin1_charset = Charset.forName("ISO-8859-1"); 
 CharsetEncode latin1_encoder = charset.newEncoder(); 
 ByteBuffer latin1_bbuf = latin1_encoder.encode(CharBuffer.wrap(some_string));
 

注意Charset和通道被设计成能够放在一起进行使用,这样就能够使得程序在内存映射、异步I/O以及编码转换进行协作的时候,能够正常运行。

总结:当然还有更多需要去了解

这篇文章的目的是为了让Java开发者能够熟悉NIO和NIO.2里的一些最主要(也是最有用)的功能。你可以通过这些示例建立起来的一些基础来理解NIO的一些其他方法;例如,你所学习的关于通道的知识能够帮助你去理解NIO的Path里对于文件系统里的符号链接的处理。你也可以参考一下我后面给出的资源列表,里面给出了一些深入学习Java新I/O API的文档。

文章来源:智云一二三科技

文章标题:快速弄懂Java 11 中的NIO 2.0

文章地址:https://www.zhihuclub.com/188655.shtml

关于作者: 智云科技

热门文章

发表回复

您的电子邮箱地址不会被公开。

网站地图