多路复用是一个在计算机网络、操作系统，以及软件开发中广泛使用的技术，它允许单一的资源（如网络连接或者CPU）同时服务于多个请求或多个应用程序。在I/O操作（输入/输出操作）的上下文中，多路复用通常指的是使用单一的线程或少量线程来同时处理多个I/O请求。
Java的NIO库提供了基于通道（Channel）和缓冲区（Buffer）的I/O操作，以及一个选择器（Selector）机制，用于非阻塞的多路复用I/O操作。通过使用选择器，一个单独的线程可以监控多个输入源的数据状态，实现多路复用：
通过选择器，一个线程可以有效地管理多个通道的I/O操作，这样即使在处理大量连接时也不需要为每个连接创建一个线程，从而大幅度降低资源消耗和提高效率。这种模型非常适合需要处理大量并发连接的服务器，例如Web服务器或应用服务器。
Java NIO（New Input/Output）和 AIO（Asynchronous Input/Output）都是Java平台上处理非阻塞I/O的技术，但它们在处理I/O操作的方式和实现机制上有着显著的差异。以下是NIO和AIO之间的主要区别：
总之，选择NIO还是AIO主要取决于具体的应用需求和预期的系统负载。对于需要处理大量并发连接且每个连接上的数据量不是很大的应用，NIO可能是一个更好的选择。而对于那些I/O操作非常耗时且需要高效率处理的应用，AIO可能更合适。
在Java中使用NIO（非阻塞IO）通常涉及到使用通道（Channels）和缓冲区（Buffers）来进行I/O操作，以及选择器（Selectors）来管理多个通道。这里将通过一个简单的服务器示例，来展示如何在Java中实现基于NIO的编程实践。
SocketChannel和ServerSocketChannel。ByteBuffer。以下是一个简单的Echo服务器实现，该服务器会将客户端发送的消息原样返回。
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编程更复杂，但它能更有效地处理成千上万的并发连接，尤其是在高负载环境下。
在Java中，AIO（异步IO）是通过Java NIO 2的扩展实现的，它在Java 7中被引入作为一种真正的异步非阻塞IO模型。AIO提供了一种机制，允许应用程序在I/O操作完成时接收通知，而无需持续检查或等待I/O操作的完成。这通过使用异步通道和完成处理器（或Future对象）实现。
AsynchronousSocketChannel和AsynchronousServerSocketChannel。这个示例将展示如何使用AIO来实现一个简单的Echo服务器，该服务器异步地接收客户端连接和数据，并将接收到的数据原样返回给客户端。
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>() {
@Override
public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
// 一旦接受连接，再次准备接受新的连接
serverChannel.accept(null, this);
handleClient(clientChannel);
}
@Override
public 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>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
attachment.flip();
clientChannel.write(attachment, attachment, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public 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();
}
}
}
@Override
public 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();
}
}
});
}
@Override
public 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();
}
}
});
}
}
AsynchronousServerSocketChannel来监听端口。这个通道被配置为异步模式，并绑定到指定端口。accept方法开始异步接受新连接，连接到来时会调用CompletionHandler的completed方法。CompletionHandler来处理读写完成后的事件。这个示例展示了AIO编程的一些基本模式，如使用异步通道和完成处理器。这种模式可以有效地处理大量并发连接，而不会造成线程阻塞，从而提高了应用程序的性能和响应能力。