架构师知识储备——深入理解BIO、NIO、AIO

开发 架构
本文你将获取到:同/异步 + 阻/非阻塞的性能区别;BIO、NIO、AIO 的区别;理解和实现 NIO 操作 Socket 时的多路复用;同时掌握 IO 最底层最核心的操作技巧。

 本文你将获取到:同/异步 + 阻/非阻塞的性能区别;BIO、NIO、AIO 的区别;理解和实现 NIO 操作 Socket 时的多路复用;同时掌握 IO 最底层最核心的操作技巧。

  • BIO、NIO、AIO 的区别是什么?
  • 同/异步、阻/非阻塞的区别是什么?
  • 文件读写最优雅的实现方式是什么?
  • NIO 如何实现多路复用功能?

带着以上这几个问题,让我们一起进入IO的世界吧。

[[279525]]

在开始之前,我们先来思考一个问题:我们经常所说的“IO”的全称到底是什么?

可能很多人看到这个问题和我一样一脸懵逼,IO的全称其实是:Input/Output的缩写。

一、IO 介绍

我们通常所说的 BIO 是相对于 NIO 来说的,BIO 也就是 Java 开始之初推出的 IO 操作模块,BIO 是 BlockingIO 的缩写,顾名思义就是阻塞 IO 的意思。

1.1 BIO、NIO、AIO的区别

BIO 就是传统的 java.io 包,它是基于流模型实现的,交互的方式是同步、阻塞方式,也就是说在读入输入流或者输出流时,在读写动作完成之前,线程会一直阻塞在那里,它们之间的调用时可靠的线性顺序。它的有点就是代码比较简单、直观;缺点就是 IO 的效率和扩展性很低,容易成为应用性能瓶颈。

NIO 是 Java 1.4 引入的 java.nio 包,提供了 Channel、Selector、Buffer 等新的抽象,可以构建多路复用的、同步非阻塞 IO 程序,同时提供了更接近操作系统底层高性能的数据操作方式。

AIO 是 Java 1.7 之后引入的包,是 NIO 的升级版本,提供了异步非堵塞的 IO 操作方式,所以人们叫它 AIO(Asynchronous IO),异步 IO 是基于事件和回调机制实现的,也就是应用操作之后会直接返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。

1.2 全面认识 IO

传统的 IO 大致可以分为4种类型:

  • InputStream、OutputStream 基于字节操作的 IO
  • Writer、Reader 基于字符操作的 IO
  • File 基于磁盘操作的 IO
  • Socket 基于网络操作的 IO

java.net 下提供的 Scoket 很多时候人们也把它归为 同步阻塞 IO ,因为网络通讯同样是 IO 行为。

java.io 下的类和接口很多,但大体都是 InputStream、OutputStream、Writer、Reader 的子集,所有掌握这4个类和File的使用,是用好 IO 的关键。

1.3 IO 使用

接下来看 InputStream、OutputStream、Writer、Reader 的继承关系图和使用示例。

1.3.1 InputStream 使用

继承关系图和类方法,如下图:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

InputStream 使用示例:

  1. InputStream inputStream = new FileInputStream("D:\\log.txt"); 
  2. byte[] bytes = new byte[inputStream.available()]; 
  3. inputStream.read(bytes); 
  4. String str = new String(bytes, "utf-8"); 
  5. System.out.println(str); 
  6. inputStream.close(); 

1.3.2 OutputStream 使用

继承关系图和类方法,如下图:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

OutputStream 使用示例:

  1. OutputStream outputStream = new FileOutputStream("D:\\log.txt",true); // 参数二,表示是否追加,true=追加 
  2. outputStream.write("你好,老王".getBytes("utf-8")); 
  3. outputStream.close(); 

1.3.3 Writer 使用

Writer 继承关系图和类方法,如下图:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

Writer 使用示例:

  1. Writer writer = new FileWriter("D:\\log.txt",true); // 参数二,是否追加文件,true=追加 
  2. writer.append("老王,你好"); 
  3. writer.close(); 

1.3.4 Reader 使用

Reader 继承关系图和类方法,如下图:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

Reader 使用示例:

  1. Reader reader = new FileReader(filePath); 
  2. BufferedReader bufferedReader = new BufferedReader(reader); 
  3. StringBuffer bf = new StringBuffer(); 
  4. String str; 
  5. while ((str = bufferedReader.readLine()) != null) { 
  6.  bf.append(str + "\n"); 
  7. bufferedReader.close(); 
  8. reader.close(); 
  9. System.out.println(bf.toString()); 

二、同步、异步、阻塞、非阻塞

上面说了很多关于同步、异步、阻塞和非阻塞的概念,接下来就具体聊一下它们4个的含义,以及组合之后形成的性能分析。

2.1 同步与异步

同步就是一个任务的完成需要依赖另外一个任务时,只有等待被依赖的任务完成后,依赖的任务才能算完成,这是一种可靠的任务序列。要么成功都成功,失败都失败,两个任务的状态可以保持一致。而异步是不需要等待被依赖的任务完成,只是通知被依赖的任务要完成什么工作,依赖的任务也立即执行,只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成,依赖它的任务无法确定,所以它是不可靠的任务序列。我们可以用打电话和发短信来很好的比喻同步与异步操作。

2.2 阻塞与非阻塞

阻塞与非阻塞主要是从 CPU 的消耗上来说的,阻塞就是 CPU 停下来等待一个慢的操作完成 CPU 才接着完成其它的事。非阻塞就是在这个慢的操作在执行时 CPU 去干其它别的事,等这个慢的操作完成时,CPU 再接着完成后续的操作。虽然表面上看非阻塞的方式可以明显的提高 CPU 的利用率,但是也带了另外一种后果就是系统的线程切换增加。增加的 CPU 使用时间能不能补偿系统的切换成本需要好好评估。

2.3 同/异、阻/非堵塞 组合

同/异、阻/非堵塞的组合,有四种类型,如下表:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

三、优雅的文件读写

Java 7 之前文件的读取是这样的:

  1. // 添加文件 
  2. FileWriter fileWriter = new FileWriter(filePath, true); 
  3. fileWriter.write(Content); 
  4. fileWriter.close(); 
  5. // 读取文件 
  6. FileReader fileReader = new FileReader(filePath); 
  7. BufferedReader bufferedReader = new BufferedReader(fileReader); 
  8. StringBuffer bf = new StringBuffer(); 
  9. String str; 
  10. while ((str = bufferedReader.readLine()) != null) { 
  11.  bf.append(str + "\n"); 
  12. bufferedReader.close(); 
  13. fileReader.close(); 
  14. System.out.println(bf.toString()); 

Java 7 引入了Files(java.nio包下)的,大大简化了文件的读写,如下:

  1. // 写入文件(追加方式:StandardOpenOption.APPEND) 
  2. Files.write(Paths.get(filePath), Content.getBytes(StandardCharsets.UTF_8), StandardOpenOption.APPEND); 
  3. // 读取文件 
  4. byte[] data = Files.readAllBytes(Paths.get(filePath)); 
  5. System.out.println(new String(data, StandardCharsets.UTF_8)); 

读写文件都是一行代码搞定,没错这就是最优雅的文件操作。

Files 下还有很多有用的方法,比如创建多层文件夹,写法上也简单了:

  1. // 创建多(单)层目录(如果不存在创建,存在不会报错) 
  2. new File("D://a//b").mkdirs(); 

四、Socket 和 NIO 的多路复用

本节带你实现最基础的 Socket 的同时,同时会实现 NIO 多路复用,还有 AIO 中 Socket 的实现。

4.1 传统的 Socket 实现

接下来我们将会实现一个简单的 Socket,服务器端只发给客户端信息,再由客户端打印出来的例子,代码如下:

  1. int port = 4343; //端口号 
  2. // Socket 服务器端(简单的发送信息) 
  3. Thread sThread = new Thread(new Runnable() { 
  4.  @Override 
  5.  public void run() { 
  6.  try { 
  7.  ServerSocket serverSocket = new ServerSocket(port); 
  8.  while (true) { 
  9.  // 等待连接 
  10.  Socket socket = serverSocket.accept(); 
  11.  Thread sHandlerThread = new Thread(new Runnable() { 
  12.  @Override 
  13.  public void run() { 
  14.  try (PrintWriter printWriter = new PrintWriter(socket.getOutputStream())) { 
  15.  printWriter.println("hello world!"); 
  16.  printWriter.flush(); 
  17.  } catch (IOException e) { 
  18.  e.printStackTrace(); 
  19.  } 
  20.  } 
  21.  }); 
  22.  sHandlerThread.start(); 
  23.  } 
  24.  } catch (IOException e) { 
  25.  e.printStackTrace(); 
  26.  } 
  27.  } 
  28. }); 
  29. sThread.start(); 
  30. // Socket 客户端(接收信息并打印) 
  31. try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) { 
  32.  BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream())); 
  33.  bufferedReader.lines().forEach(s -> System.out.println("客户端:" + s)); 
  34. } catch (UnknownHostException e) { 
  35.  e.printStackTrace(); 
  36. } catch (IOException e) { 
  37.  e.printStackTrace(); 
  • 调用 accept 方法,阻塞等待客户端连接;
  • 利用 Socket 模拟了一个简单的客户端,只进行连接、读取和打印;

在 Java 中,线程的实现是比较重量级的,所以线程的启动或者销毁是很消耗服务器的资源的,即使使用线程池来实现,使用上述传统的 Socket 方式,当连接数极具上升也会带来性能瓶颈,原因是线程的上线文切换开销会在高并发的时候体现的很明显,并且以上操作方式还是同步阻塞式的编程,性能问题在高并发的时候就会体现的尤为明显。

以上的流程,如下图:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

4.2 NIO 多路复用

介于以上高并发的问题,NIO 的多路复用功能就显得意义非凡了。

NIO 是利用了单线程轮询事件的机制,通过高效地定位就绪的 Channel,来决定做什么,仅仅 select 阶段是阻塞的,可以有效避免大量客户端连接时,频繁线程切换带来的问题,应用的扩展能力有了非常大的提高。

  1. // NIO 多路复用 
  2. ThreadPoolExecutor threadPool = new ThreadPoolExecutor(4, 4, 
  3.  60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); 
  4. threadPool.execute(new Runnable() { 
  5.  @Override 
  6.  public void run() { 
  7.  try (Selector selector = Selector.open(); 
  8.  ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();) { 
  9.  serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), port)); 
  10.  serverSocketChannel.configureBlocking(false); 
  11.  serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); 
  12.  while (true) { 
  13.  selector.select(); // 阻塞等待就绪的Channel 
  14.  Set<SelectionKey> selectionKeys = selector.selectedKeys(); 
  15.  Iterator<SelectionKey> iterator = selectionKeys.iterator(); 
  16.  while (iterator.hasNext()) { 
  17.  SelectionKey key = iterator.next(); 
  18.  try (SocketChannel channel = ((ServerSocketChannel) key.channel()).accept()) { 
  19.  channel.write(Charset.defaultCharset().encode("你好,世界")); 
  20.  } 
  21.  iterator.remove(); 
  22.  } 
  23.  } 
  24.  } catch (IOException e) { 
  25.  e.printStackTrace(); 
  26.  } 
  27.  } 
  28. }); 
  29. // Socket 客户端(接收信息并打印) 
  30. try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) { 
  31.  BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream())); 
  32.  bufferedReader.lines().forEach(s -> System.out.println("NIO 客户端:" + s)); 
  33. } catch (IOException e) { 
  34.  e.printStackTrace(); 
  • 首先,通过 Selector.open() 创建一个 Selector,作为类似调度员的角色;
  • 然后,创建一个 ServerSocketChannel,并且向 Selector 注册,通过指定 SelectionKey.OP_ACCEPT,告诉调度员,它关注的是新的连接请求;
  • 为什么我们要明确配置非阻塞模式呢?这是因为阻塞模式下,注册操作是不允许的,会抛出 IllegalBlockingModeException 异常;
  • Selector 阻塞在 select 操作,当有 Channel 发生接入请求,就会被唤醒;

下面的图,可以有效的说明 NIO 复用的流程:

 

架构师知识储备——深入理解BIO、NIO、AIO

 

就这样 NIO 的多路复用就大大提升了服务器端响应高并发的能力。

4.3 AIO 版 Socket 实现

Java 1.7 提供了 AIO 实现的 Socket 是这样的,如下代码:

  1. // AIO线程复用版 
  2. Thread sThread = new Thread(new Runnable() { 
  3.  @Override 
  4.  public void run() { 
  5.  AsynchronousChannelGroup group = null
  6.  try { 
  7.  group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(4)); 
  8.  AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group).bind(new InetSocketAddress(InetAddress.getLocalHost(), port)); 
  9.  server.accept(null, new CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>() { 
  10.  @Override 
  11.  public void completed(AsynchronousSocketChannel result, AsynchronousServerSocketChannel attachment) { 
  12.  server.accept(null, this); // 接收下一个请求 
  13.  try { 
  14.  Future<Integer> f = result.write(Charset.defaultCharset().encode("你好,世界")); 
  15.  f.get(); 
  16.  System.out.println("服务端发送时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); 
  17.  result.close(); 
  18.  } catch (InterruptedException | ExecutionException | IOException e) { 
  19.  e.printStackTrace(); 
  20.  } 
  21.  } 
  22.  @Override 
  23.  public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) { 
  24.  } 
  25.  }); 
  26.  group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); 
  27.  } catch (IOException | InterruptedException e) { 
  28.  e.printStackTrace(); 
  29.  } 
  30.  } 
  31. }); 
  32. sThread.start(); 
  33. // Socket 客户端 
  34. AsynchronousSocketChannel client = AsynchronousSocketChannel.open(); 
  35. Future<Void> future = client.connect(new InetSocketAddress(InetAddress.getLocalHost(), port)); 
  36. future.get(); 
  37. ByteBuffer buffer = ByteBuffer.allocate(100); 
  38. client.read(buffer, null, new CompletionHandler<Integer, Void>() { 
  39.  @Override 
  40.  public void completed(Integer result, Void attachment) { 
  41.  System.out.println("客户端打印:" + new String(buffer.array())); 
  42.  } 
  43.  @Override 
  44.  public void failed(Throwable exc, Void attachment) { 
  45.  exc.printStackTrace(); 
  46.  try { 
  47.  client.close(); 
  48.  } catch (IOException e) { 
  49.  e.printStackTrace(); 
  50.  } 
  51.  } 
  52. }); 
  53. Thread.sleep(10 * 1000); 

五、总结

以上基本就是 IO 从 1.0 到目前版本(本文的版本)JDK 8 的核心使用操作了,可以看出来 IO 作为比较常用的基础功能,发展变化的改动也很大,而且使用起来也越来越简单了,IO 的操作也是比较好理解的,一个输入一个输出,掌握好了输入输出也就掌握好了 IO,Socket 作为网络交互的集成功能,显然 NIO 的多路复用,给 Socket 带来了更多的活力和选择,用户可以根据自己的实际场景选择相应的代码策略。

责任编辑:武晓燕 来源: 今日头条
相关推荐

2022-04-16 16:52:24

Netty网络服务器客户端程序

2020-04-16 15:20:43

PHP前端BIO

2020-10-10 19:37:27

BIO 、NIO 、A

2017-08-15 13:05:58

Serverless架构开发运维

2021-08-18 07:56:04

AndroidRecyclerVie复用

2023-06-07 15:34:21

架构层次结构

2023-07-11 08:40:02

IO模型后台

2019-03-18 09:50:44

Nginx架构服务器

2018-12-27 12:34:42

HadoopHDFS分布式系统

2018-04-16 11:04:23

HBaseRegion Serv数据库

2022-01-14 12:28:18

架构OpenFeign远程

2021-08-12 18:48:31

响应式编程Bio

2019-09-24 13:41:22

Hadoop面试分布式

2021-09-03 09:55:43

架构Yarn内部

2023-01-16 18:32:15

架构APNacos

2021-06-11 17:26:06

代码Java网络编程

2023-06-26 07:39:10

2010-06-01 15:25:27

JavaCLASSPATH

2016-12-08 15:36:59

HashMap数据结构hash函数

2020-07-21 08:26:08

SpringSecurity过滤器
点赞
收藏

51CTO技术栈公众号