java BIO、NIO、AIO用法样例

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：性能较好，复杂度高，适合高并发短连接（Netty 基于 NIO）。
• AIO：性能最佳，但编程复杂，在 Linux 上优势不明显（Linux 对 AIO 支持有限，常用 NIO）。

实际项目中，NIO 框架（如 Netty）使用最广泛，平衡了性能和复杂度。