阅读量:0
在Java中，处理I/O操作的模型主要有四种：阻塞I/O (BIO), 非阻塞I/O (NIO), 异步I/O (AIO), 以及IO多路复用。下面详细介绍这四种I/O模型的工作原理和应用场景。
1. 阻塞I/O (BIO)
工作原理
阻塞I/O是最传统的I/O模型。在这种模型中，当一个线程发起一个I/O请求（如读写操作）时，该线程会被阻塞，直到I/O操作完成。这意味着线程必须等待I/O操作完成才能继续执行。
代码示例
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; public class BioServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(8080); System.out.println("Server started on port 8080"); while (true) { Socket clientSocket = serverSocket.accept(); // 阻塞等待客户端连接 new Thread(() -> { try (BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) { String line; while ((line = reader.readLine()) != null) { System.out.println("Received: " + line); } } catch (IOException e) { e.printStackTrace(); } }).start(); } } } 优点
- 实现简单。
缺点
- 每个连接都需要一个线程来处理，当并发连接数增加时，线程的数量也会增加，可能导致系统资源耗尽。
2. 非阻塞I/O (NIO)
工作原理
非阻塞I/O模型允许线程在发起I/O请求时不会被阻塞，如果数据不可用或设备忙，则立即返回一个错误或特殊值。线程可以选择立即再次尝试I/O操作或去做其他事情，从而提高了CPU的利用率。
代码示例
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; public class NioServer { public static void main(String[] args) throws IOException { Selector selector = Selector.open(); ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind(new InetSocketAddress(8080)); serverSocketChannel.configureBlocking(false); serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while (true) { selector.select(); Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> keyIterator = selectedKeys.iterator(); while (keyIterator.hasNext()) { SelectionKey key = keyIterator.next(); if (key.isAcceptable()) { ServerSocketChannel ssc = (ServerSocketChannel) key.channel(); SocketChannel sc = ssc.accept(); sc.configureBlocking(false); sc.register(selector, SelectionKey.OP_READ); } else if (key.isReadable()) { SocketChannel sc = (SocketChannel) key.channel(); ByteBuffer buffer = ByteBuffer.allocate(1024); int readBytes = sc.read(buffer); if (readBytes > 0) { buffer.flip(); byte[] data = new byte[buffer.remaining()]; buffer.get(data); System.out.println("Received: " + new String(data)); } } keyIterator.remove(); } } } } 优点
- 提高了单个线程处理多个连接的能力，降低了系统资源消耗。
- 可以处理大量并发连接。
缺点
- 实现相对复杂。
- 需要手动管理缓冲区、选择器等。
3. IO多路复用
工作原理
IO多路复用允许一个进程同时监听多个文件描述符（例如socket），并只在某个描述符准备好进行读写操作时才进行处理。常用的多路复用机制有select、poll和epoll。这种模型非常适合处理大量并发连接的场景。
代码示例
import java.io.IOException; import java.net.InetSocketAddress; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; public class SelectServer { public static void main(String[] args) throws IOException { Selector selector = Selector.open(); ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind(new InetSocketAddress(8080)); serverSocketChannel.configureBlocking(false); serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while (true) { selector.select(); for (SelectionKey key : selector.selectedKeys()) { if (key.isAcceptable()) { ServerSocketChannel ssc = (ServerSocketChannel) key.channel(); SocketChannel sc = ssc.accept(); sc.configureBlocking(false); sc.register(selector, SelectionKey.OP_READ); } else if (key.isReadable()) { SocketChannel sc = (SocketChannel) key.channel(); // 读取数据... } } selector.selectedKeys().clear(); } } } 优点
- 可以同时监听多个文件描述符，提高处理大量并发连接的能力。
- 提高了资源利用率。
缺点
- 在Java中，
select和poll的性能不如epoll，后者仅在Linux系统中可用。
4. 异步I/O (AIO)
工作原理
异步I/O是真正的异步操作模型，进程发起I/O请求后可以立即返回并继续执行其他任务，而无需等待I/O操作完成。当I/O操作完成后，操作系统会通知进程结果。
代码示例
import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.AsynchronousServerSocketChannel; import java.nio.channels.AsynchronousSocketChannel; import java.nio.channels.CompletionHandler; import java.util.concurrent.CountDownLatch; public class AioServer { private static final CountDownLatch latch = new CountDownLatch(1); public static void main(String[] args) throws IOException, InterruptedException { AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open().bind(new java.net.InetSocketAddress(8080)); server.accept(null, new AcceptHandler(server)); latch.await(); } static class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, Object> { private AsynchronousServerSocketChannel server; public AcceptHandler(AsynchronousServerSocketChannel server) { this.server = server; } @Override public void completed(AsynchronousSocketChannel result, Object attachment) { result.read(ByteBuffer.allocate(1024), null, new ReadHandler(result)); server.accept(null, this); } @Override public void failed(Throwable exc, Object attachment) { exc.printStackTrace(); latch.countDown(); } } static class ReadHandler implements CompletionHandler<Integer, Object> { private AsynchronousSocketChannel channel; public ReadHandler(AsynchronousSocketChannel channel) { this.channel = channel; } @Override public void completed(Integer result, Object attachment) { ByteBuffer buffer = (ByteBuffer) attachment; buffer.flip(); byte[] data = new byte[buffer.remaining()]; buffer.get(data); System.out.println("Received: " + new String(data)); channel.close(); } @Override public void failed(Throwable exc, Object attachment) { exc.printStackTrace(); try { ((AsynchronousSocketChannel) attachment).close(); } catch (IOException e) { e.printStackTrace(); } } } } 优点
- 真正的异步操作，提高了系统的并发能力和响应速度。
- 适用于高并发场景。
缺点
- 实现较为复杂。
- Java中AIO的支持相对较少，不如NIO成熟。
总结
- BIO：适合连接数较少的场景。
- NIO：适用于中等并发的场景，提高了资源利用率。
- IO多路复用：适合大量并发连接的场景，特别是在服务器端。
- AIO：适用于高并发场景，真正实现了异步操作。
选择哪种模型取决于具体的应用场景和需求。例如，对于需要处理大量并发连接的服务器，IO多路复用和异步I/O可能是更佳的选择。而对于简单的、单线程的应用，阻塞I/O可能就已经足够。
