1. BIO (Blocking I/O) - 同步阻塞 I/O
BIO 是传统的网络编程模型，每个连接对应一个线程，当线程执行读/写操作时会被阻塞，直到数据就绪。
示例：BIO 服务器
importjava.net.*;importjava.io.*;publicclassBioServer{publicstaticvoidmain(String[]args)throwsIOException{ServerSocketserverSocket=newServerSocket(8080);System.out.println("BIO Server started on port 8080");while(true){SocketclientSocket=serverSocket.accept();// 阻塞等待客户端连接newThread(()->{try{BufferedReaderin=newBufferedReader(newInputStreamReader(clientSocket.getInputStream()));PrintWriterout=newPrintWriter(clientSocket.getOutputStream(),true);Stringrequest;while((request=in.readLine())!=null){// 阻塞读取数据System.out.println("Received: "+request);out.println("Echo: "+request);// 响应客户端}clientSocket.close();}catch(IOExceptione){e.printStackTrace();}}).start();}}}特点：
- 每个连接一个线程，适合连接数少的场景。
- 编程简单，但线程开销大，无法应对高并发。
2. NIO (Non-blocking I/O) - 同步非阻塞 I/O
NIO 基于 Channel 和 Selector，使用单个线程管理多个连接，通过事件驱动机制实现非阻塞。
示例：NIO 服务器
importjava.net.*;importjava.nio.*;importjava.nio.channels.*;importjava.util.*;publicclassNioServer{publicstaticvoidmain(String[]args)throwsIOException{ServerSocketChannelserverChannel=ServerSocketChannel.open();serverChannel.bind(newInetSocketAddress(8080));serverChannel.configureBlocking(false);// 非阻塞模式Selectorselector=Selector.open();serverChannel.register(selector,SelectionKey.OP_ACCEPT);// 注册接受连接事件System.out.println("NIO Server started on port 8080");while(true){selector.select();// 阻塞直到有事件发生Set<SelectionKey>keys=selector.selectedKeys();Iterator<SelectionKey>iter=keys.iterator();while(iter.hasNext()){SelectionKeykey=iter.next();iter.remove();if(key.isAcceptable()){ServerSocketChannelserver=(ServerSocketChannel)key.channel();SocketChannelclient=server.accept();client.configureBlocking(false);client.register(selector,SelectionKey.OP_READ);// 注册读事件System.out.println("Client connected: "+client.getRemoteAddress());}elseif(key.isReadable()){SocketChannelclient=(SocketChannel)key.channel();ByteBufferbuffer=ByteBuffer.allocate(1024);intread=client.read(buffer);// 非阻塞读取if(read>0){buffer.flip();byte[]data=newbyte[buffer.remaining()];buffer.get(data);Stringrequest=newString(data);System.out.println("Received: "+request);// 响应客户端ByteBufferresponse=ByteBuffer.wrap(("Echo: "+request).getBytes());client.write(response);}elseif(read==-1){client.close();}}}}}}特点：
- 单线程处理多连接，减少线程开销。
- 复杂度较高，需要处理事件循环和缓冲区。
3. AIO (Asynchronous I/O) - 异步非阻塞 I/O
AIO 基于回调机制，应用程序发起 I/O 操作后立即返回，当操作完成时系统会通知应用程序。
示例：AIO 服务器
importjava.net.*;importjava.nio.*;importjava.nio.channels.*;importjava.util.concurrent.*;publicclassAioServer{publicstaticvoidmain(String[]args)throwsIOException{AsynchronousServerSocketChannelserver=AsynchronousServerSocketChannel.open();server.bind(newInetSocketAddress(8080));System.out.println("AIO Server started on port 8080");// 接受连接的回调server.accept(null,newCompletionHandler<AsynchronousSocketChannel,Void>(){@Overridepublicvoidcompleted(AsynchronousSocketChannelclient,Voidattachment){server.accept(null,this);// 继续接受下一个连接ByteBufferbuffer=ByteBuffer.allocate(1024);// 读取数据的回调client.read(buffer,buffer,newCompletionHandler<Integer,ByteBuffer>(){@Overridepublicvoidcompleted(IntegerbytesRead,ByteBufferbuffer){if(bytesRead>0){buffer.flip();byte[]data=newbyte[buffer.remaining()];buffer.get(data);Stringrequest=newString(data);System.out.println("Received: "+request);// 响应客户端ByteBufferresponse=ByteBuffer.wrap(("Echo: "+request).getBytes());client.write(response,null,newCompletionHandler<Integer,Void>(){@Overridepublicvoidcompleted(Integerresult,Voidattachment){try{client.close();}catch(IOExceptione){e.printStackTrace();}}@Overridepublicvoidfailed(Throwableexc,Voidattachment){exc.printStackTrace();}});}}@Overridepublicvoidfailed(Throwableexc,ByteBufferattachment){exc.printStackTrace();}});}@Overridepublicvoidfailed(Throwableexc,Voidattachment){exc.printStackTrace();}});// 保持服务器运行Thread.currentThread().join();}}特点：
- 完全异步，基于回调或 Future，性能高。
- 编程模型复杂，适合连接数多且长连接的场景。
对比分析
| 特性 | BIO | NIO | AIO |
|---|---|---|---|
| 模型 | 同步阻塞 | 同步非阻塞（多路复用） | 异步非阻塞 |
| 线程数 | 一个连接一个线程 | 一个线程处理多个连接 | 少量线程，回调驱动 |
| 吞吐量 | 低（线程上下文切换开销大） | 中高 | 高 |
| 编程复杂度 | 简单 | 复杂（需处理 Selector 等） | 非常复杂（回调地狱） |
| 适用场景 | 连接数少、固定架构 | 连接数多、短连接（如聊天） | 连接数多、长连接（如文件传输） |
| JDK 版本 | Java 1.0+ | Java 1.4+ | Java 1.7+ |
总结
- BIO：简单但性能差，适合低并发场景。
- NIO：性能较好，复杂度高，适合高并发短连接（Netty 基于 NIO）。
- AIO：性能最佳，但编程复杂，在 Linux 上优势不明显（Linux 对 AIO 支持有限，常用 NIO）。
实际项目中，NIO 框架（如 Netty）使用最广泛，平衡了性能和复杂度。
