Java NIOAIO

多路复用概念介绍

多路复用是一个在计算机网络、操作系统，以及软件开发中广泛使用的技术，它允许单一的资源（如网络连接或者CPU）同时服务于多个请求或多个应用程序。在I/O操作（输入/输出操作）的上下文中，多路复用通常指的是使用单一的线程或少量线程来同时处理多个I/O请求。

多路复用的主要形式

I/O多路复用（在网络编程中常见）：
- 使用单一的线程监听多个网络连接，处理所有的输入和输出请求。这通常涉及到监听哪些连接上有数据可以读取，或者哪些连接准备好可以写入数据而不会被阻塞。
- 常见的实现技术包括使用select, poll, 或 epoll（在Linux系统中）。
异步I/O（AIO）：
- 异步I/O模型允许应用程序启动一个或多个I/O操作，然后继续执行其他任务，无需等待这些操作完成。当I/O操作实际完成时，应用程序将接收到通知。
- 在Java中，这通过使用AsynchronousFileChannel或AsynchronousSocketChannel等类实现。

多路复用与阻塞/非阻塞I/O的关系

阻塞I/O：在这种模型下，应用程序发起一个I/O操作后，必须等待操作完成才能继续执行。在等待期间，应用程序的线程被挂起。
非阻塞I/O：在非阻塞模式下，I/O调用将立即返回一个状态，告诉应用程序数据是否可用。如果数据未就绪，应用程序可以做其他事情，而不是等待，从而提高了应用程序的效率。

Java NIO中的多路复用

Java的NIO库提供了基于通道（Channel）和缓冲区（Buffer）的I/O操作，以及一个选择器（Selector）机制，用于非阻塞的多路复用I/O操作。通过使用选择器，一个单独的线程可以监控多个输入源的数据状态，实现多路复用：

选择器（Selector）：一个可以监控一组通道的对象，用来检查哪一个或哪几个通道已经准备好进行读取或写入。
通道（Channel）：类似于传统的流，但它们可以被设置为非阻塞模式。在非阻塞模式下，应用程序可以请求读写操作，并且立即得到返回，不需要等待操作实际完成。

通过选择器，一个线程可以有效地管理多个通道的I/O操作，这样即使在处理大量连接时也不需要为每个连接创建一个线程，从而大幅度降低资源消耗和提高效率。这种模型非常适合需要处理大量并发连接的服务器，例如Web服务器或应用服务器。

Java NIO&AIO简介

Java NIO（New Input/Output）和 AIO（Asynchronous Input/Output）都是Java平台上处理非阻塞I/O的技术，但它们在处理I/O操作的方式和实现机制上有着显著的差异。以下是NIO和AIO之间的主要区别：

1. 操作模式

NIO 是基于事件驱动的非阻塞I/O模型。它使用**选择器（Selectors）和通道（Channels）**的概念，通过一个线程来监控多个输入通道，看是否有数据准备好可以被读取或写入。当数据准备好时，系统将通知应用程序，应用程序再进行实际的读写操作。
AIO 是真正的异步I/O，它不需要周期性地检查数据是否可用。AIO引入了异步通道的概念，允许应用程序直接进行读写操作，并在操作完成后通过回调函数或者Future对象处理结果。

2. 性能和资源利用

NIO 虽然是非阻塞的，但在处理大量连接时可能需要频繁地检查所有连接的状态，这种模型可能导致资源的浪费（尽管相比于传统的阻塞IO已经大幅改进）。
AIO 提供了更高的性能和更好的资源利用率，在处理成千上万的并发连接时表现更优，因为它通过操作系统的直接支持来异步处理I/O操作，减少了不必要的CPU消耗。

3. 应用场景

NIO 适合于连接数目较多但每个连接上的数据传输量不是特别大的场景，如网络服务器。
AIO 更适合于高负载、高并发的应用场景，特别是在I/O操作非常耗时的情况下（如大文件传输），能够有效地提升性能。

4. API复杂度

NIO 的API相对复杂，需要管理缓冲区、选择键（SelectionKey）等，同时还需要处理线程安全和数据同步等问题。
AIO 的API设计更为简洁直观，使用起来更加方便，特别是在进行复杂的异步操作时，可以使代码更加清晰。

5. 支持和可用性

NIO 从Java 1.4开始引入，而完整的NIO.2（包括对文件系统的改进）是在Java 7中引入的。
AIO 是在Java 7中引入的，是Java平台对真异步I/O的支持。

总之，选择NIO还是AIO主要取决于具体的应用需求和预期的系统负载。对于需要处理大量并发连接且每个连接上的数据量不是很大的应用，NIO可能是一个更好的选择。而对于那些I/O操作非常耗时且需要高效率处理的应用，AIO可能更合适。

NIO编程

在Java中使用NIO（非阻塞IO）通常涉及到使用通道（Channels）和缓冲区（Buffers）来进行I/O操作，以及选择器（Selectors）来管理多个通道。这里将通过一个简单的服务器示例，来展示如何在Java中实现基于NIO的编程实践。

NIO编程关键组件

通道 (Channel)：类似于流，但主要区别在于通道是双向的，可以读也可以写。最常用的是SocketChannel和ServerSocketChannel。
缓冲区 (Buffer)：数据的容器。数据从通道读入缓冲区，从缓冲区写入通道。例如ByteBuffer。
选择器 (Selector)：可以监视多个通道的IO状况，是单线程管理多个连接实现非阻塞IO的关键。

示例：基于NIO的Echo服务器

以下是一个简单的Echo服务器实现，该服务器会将客户端发送的消息原样返回。

步骤1：设置服务器通道和选择器

import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.*;public class EchoServer {public static void main(String[] args) throws Exception {// 创建选择器Selector selector = Selector.open();// 打开服务器Socket通道ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式serverSocketChannel.socket().bind(new InetSocketAddress(8080));serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);System.out.println("Server started on port 8080");while (true) {// 非阻塞模式，选择器每隔一定时间检查一次注册的通道if (selector.select() == 0) {continue;}// 获取所有接收事件的SelectionKey实例Set<SelectionKey> selectedKeys = selector.selectedKeys();Iterator<SelectionKey> iter = selectedKeys.iterator();while (iter.hasNext()) {SelectionKey key = iter.next();// 根据事件类型进行处理if (key.isAcceptable()) {// 接受客户端连接请求handleAccept(serverSocketChannel, selector);} else if (key.isReadable()) {// 读取数据handleRead(key);}iter.remove();}}}private static void handleAccept(ServerSocketChannel serverSocketChannel, Selector selector) throws Exception {SocketChannel clientChannel = serverSocketChannel.accept();clientChannel.configureBlocking(false);clientChannel.register(selector, SelectionKey.OP_READ);System.out.println("Accepted connection from " + clientChannel);}private static void handleRead(SelectionKey key) throws Exception {SocketChannel clientChannel = (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(1024);int numRead = clientChannel.read(buffer);if (numRead == -1) {clientChannel.close();key.cancel();System.out.println("Connection closed by client");return;}// 回显数据buffer.flip();byte[] data = new byte[buffer.remaining()];buffer.get(data);System.out.println("Received: " + new String(data, StandardCharsets.UTF_8));// 将数据写回客户端clientChannel.write(ByteBuffer.wrap(data));}
}

解释

服务器设置：服务器通道被设置为非阻塞并注册到选择器。关注的事件是OP_ACCEPT，表示服务器准备好接受新的客户端连接。
事件循环：服务器在一个无限循环中运行，等待并处理事件（接受连接或读取数据）。
处理连接和读取：当selector发现有新的客户端连接时，它会接受连接并将返回的SocketChannel设置为非阻塞，然后注册到选择器上，关注读事件。读事件触发时，数据被读入ByteBuffer，并简单地回显到客户端。

这个示例展示了使用Java NIO来创建一个简单的服务器的基本步骤。NIO编程比标准的IO编程更复杂，但它能更有效地处理成千上万的并发连接，尤其是在高负载环境下。

AIO编程

在Java中，AIO（异步IO）是通过Java NIO 2的扩展实现的，它在Java 7中被引入作为一种真正的异步非阻塞IO模型。AIO提供了一种机制，允许应用程序在I/O操作完成时接收通知，而无需持续检查或等待I/O操作的完成。这通过使用异步通道和完成处理器（或Future对象）实现。

AIO编程的关键组件

异步通道：这些是用于数据读写的通道，如AsynchronousSocketChannel和AsynchronousServerSocketChannel。
完成处理器：一个实现了特定回调方法的对象，当异步操作完成时被调用。
Future对象：另一种处理异步操作结果的方式，可以用来查询操作是否完成，或阻塞等待操作完成。

示例：基于AIO的Echo服务器

这个示例将展示如何使用AIO来实现一个简单的Echo服务器，该服务器异步地接收客户端连接和数据，并将接收到的数据原样返回给客户端。

步骤1：创建服务器通道

import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.concurrent.*;public class AsyncEchoServer {public static void main(String[] args) {try {// 打开异步服务器通道AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();serverChannel.bind(new InetSocketAddress(8080));System.out.println("Server is listening at " + 8080);serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {@Overridepublic void completed(AsynchronousSocketChannel clientChannel, Void attachment) {// 一旦接受连接，再次准备接受新的连接serverChannel.accept(null, this);handleClient(clientChannel);}@Overridepublic void failed(Throwable exc, Void attachment) {System.out.println("Failed to accept new connection");exc.printStackTrace();}});// 服务器需要一直运行，使用CountDownLatch来阻塞new CountDownLatch(1).await();} catch (IOException | InterruptedException e) {e.printStackTrace();}}private static void handleClient(AsynchronousSocketChannel clientChannel) {ByteBuffer buffer = ByteBuffer.allocate(1024);clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {@Overridepublic void completed(Integer result, ByteBuffer attachment) {attachment.flip();clientChannel.write(attachment, attachment, new CompletionHandler<Integer, ByteBuffer>() {@Overridepublic void completed(Integer result, ByteBuffer buffer) {if (buffer.hasRemaining()) {buffer.compact();clientChannel.read(buffer, buffer, this);} else {try {clientChannel.close();} catch (IOException e) {e.printStackTrace();}}}@Overridepublic void failed(Throwable exc, ByteBuffer attachment) {System.out.println("Failed to write data to client");exc.printStackTrace();try {clientChannel.close();} catch (IOException e) {e.printStackTrace();}}});}@Overridepublic void failed(Throwable exc, ByteBuffer attachment) {System.out.println("Failed to read data from client");exc.printStackTrace();try {clientChannel.close();} catch (IOException e) {e.printStackTrace();}}});}
}