Java IO/NIO/AIO 演进从 BIO 到 Netty 的底层逻辑IO 模型是 Java 面试的硬核考点。从 BIO 到 NIO 再到 Netty背后是操作系统 I/O 模型的演进。本文把 IO 的底层逻辑一次讲透。一、操作系统 I/O 模型基础在理解 Java IO 之前先看操作系统的 5 种 I/O 模型┌───────────────────────────────────────────────────────────┐ │ 操作系统 I/O 模型对比 │ ├───────────────────────────────────────────────────────────┤ │ │ │ 1. 阻塞 I/O (BIO) │ │ 用户线程 ──调用read──▶ 内核 ──等待数据──▶ 内核 ──拷贝数据──▶ 用户 │ │ ↑ 整个过程阻塞 │ │ │ │ 2. 非阻塞 I/O (Non-blocking IO) │ │ 用户线程 ──调用read──▶ 内核(立即返回) │ │ 用户线程 ──轮询read──▶ 内核(数据好了吗?) │ │ 用户线程 ──read──▶ 内核 ──拷贝──▶ 用户 │ │ ↑ read 不阻塞但要轮询 │ │ │ │ 3. I/O 多路复用 (select/poll/epoll) │ │ 用户线程 ──调用select──▶ 内核(监听多个fd) │ │ 内核: 有fd就绪了! → 用户线程read │ │ ↑ 一个线程监听多个连接 │ │ │ │ 4. 信号驱动 I/O (SIGIO) │ │ 用户线程 ──注册信号──▶ 内核 │ │ 内核: 数据好了! (信号) → 用户线程read │ │ │ │ 5. 异步 I/O (AIO) │ │ 用户线程 ──调用aio_read──▶ 内核(立即返回) │ │ 内核: 自己等数据拷贝 → 完成后通知用户线程 │ │ ↑ 整个过程用户线程不阻塞内核完成一切 │ │ │ └───────────────────────────────────────────────────────────┘关键区别: BIO: 阻塞 单连接单线程 NIO: 非阻塞 多路复用(一个线程管理多个连接) AIO: 异步 内核完成所有操作(Callback通知) NIO vs AIO: NIO: 用户线程自己轮询/读取 → 同步非阻塞 AIO: 内核完成读取后通知 → 真正异步二、Java BIO一连接一线程// BIO 服务端: 每个连接一个线程publicclassBioServer{publicstaticvoidmain(String[]args)throwsIOException{ServerSocketserverSocketnewServerSocket(8080);while(true){SocketsocketserverSocket.accept();// 阻塞等待连接newThread(()-handle(socket)).start();// 每个连接一个线程}}privatestaticvoidhandle(Socketsocket){try{InputStreaminsocket.getInputStream();OutputStreamoutsocket.getOutputStream();byte[]bufnewbyte[1024];intlenin.read(buf);// 阻塞等待数据out.write(hello.getBytes());}catch(IOExceptione){e.printStackTrace();}}}BIO 瓶颈: 1000 个连接 → 1000 个线程 ├── 每个线程约 1MB 栈空间 → 1GB 内存 ├── 线程切换开销巨大 ├── 大部分线程在 in.read() 上阻塞 └── 无法支撑 C10K (1万并发连接) ┌────────┐ ┌────────┐ ┌────────┐ │ Thread1│ │ Thread2│ │ ThreadN│ │ read()│ │ read()│ │ read()│ ← 大部分时间在阻塞 │ 阻塞... │ │ 阻塞...│ │ 阻塞...│ └────────┘ └────────┘ └────────┘ ↑ ↑ ↑ └──────────────┴──────────────┘ │ ┌─────┴─────┐ │ Selector │ ← NIO: 一个线程管理所有连接 └───────────┘BIO 线程池优化// 线程池版 BIO (缓解但不能解决)publicclassBioPoolServer{privatestaticfinalExecutorServicepoolExecutors.newFixedThreadPool(200);publicstaticvoidmain(String[]args)throwsIOException{ServerSocketserverSocketnewServerSocket(8080);while(true){SocketsocketserverSocket.accept();pool.submit(()-handle(socket));}}}// 最多 200 个并发连接第 201 个连接排队等待// 仍然无法突破 C10K三、Java NIOBuffer Channel Selector1. Buffer// Buffer 是 NIO 的数据容器ByteBufferbufferByteBuffer.allocate(1024);// Buffer 三个核心指针:// position: 当前读写位置// limit: 读写限制// capacity: 总容量// 写模式:buffer.put((byte)H);buffer.put((byte)i);// position2, limit1024, capacity1024buffer.flip();// 切换到读模式// position0, limit2, capacity1024// 读模式:bytebbuffer.get();// H// position1, limit2, capacity1024buffer.clear();// 清空准备再写// position0, limit1024, capacity1024Buffer 状态转换: 写模式: flip() 读模式: ┌───────────────────┐ ┌───────────────────┐ │ capacity1024 │ │ capacity1024 │ │ limit1024 │ ─────────────▶ │ limit2 │ │ position2 │ │ position0 │ │ ┌─┬─┬─┬─┬─┬─┬─┐ │ │ ┌─┬─┬─┬─┬─┬─┬─┐ │ │ │H│i│ │ │ │ │ │ │ │ │H│i│ │ │ │ │ │ │ │ └─┴─┴─┴─┴─┴─┴─┘ │ │ └─┴─┴─┴─┴─┴─┴─┘ │ │ ↑ │ │ ↑ │ │ position │ │ position │ └───────────────────┘ └───────────────────┘2. Channel// Channel 是双向数据通道// 可读可写支持非阻塞模式// 文件 ChannelFileChannelfcnewFileInputStream(file.txt).getChannel();// 网络 ChannelServerSocketChannelsscServerSocketChannel.open();ssc.bind(newInetSocketAddress(8080));ssc.configureBlocking(false);// 非阻塞模式SocketChannelscSocketChannel.open();sc.configureBlocking(false);sc.connect(newInetSocketAddress(localhost,8080));3. Selector核心// Selector 是 NIO 的核心: 一个线程管理多个 ChannelpublicclassNioServer{publicstaticvoidmain(String[]args)throwsIOException{SelectorselectorSelector.open();ServerSocketChannelsscServerSocketChannel.open();ssc.configureBlocking(false);ssc.bind(newInetSocketAddress(8080));ssc.register(selector,SelectionKey.OP_ACCEPT);// 注册 Accept 事件while(true){selector.select();// 阻塞等待事件就绪SetSelectionKeykeysselector.selectedKeys();IteratorSelectionKeyitkeys.iterator();while(it.hasNext()){SelectionKeykeyit.next();it.remove();if(key.isAcceptable()){SocketChannelscssc.accept();sc.configureBlocking(false);sc.register(selector,SelectionKey.OP_READ);}elseif(key.isReadable()){SocketChannelsc(SocketChannel)key.channel();ByteBufferbufByteBuffer.allocate(1024);intlensc.read(buf);if(len0){buf.flip();sc.write(buf);}elseif(len-1){sc.close();}}}}}}Selector 工作原理: ┌───────────────────────────────────────────────────┐ │ 单线程 Selector │ │ │ │ ┌──────────────────────────────────────────┐ │ │ │ Selector │ │ │ │ ┌─────────┬─────────┬─────────┐ │ │ │ │ │ OP_ACCEPT│ OP_READ │ OP_WRITE│ ... │ │ │ │ └────┬────┴────┬────┴────┬────┘ │ │ │ └───────┼─────────┼─────────┼────────────────┘ │ │ │ │ │ │ │ ┌─────▼───┐ ┌───▼───┐ ┌───▼───┐ │ │ │Channel 1│ │Chann 2│ │Chann N│ ... │ │ │(连接1) │ │(连接2)│ │(连接N)│ │ │ └─────────┘ └───────┘ └───────┘ │ │ │ │ selector.select() 返回就绪的 Channel 数量 │ │ 只处理有数据的 Channel不轮询空闲连接 │ │ │ │ 1 个线程 → 管理 10000 连接 │ └───────────────────────────────────────────────────┘4. epoll vs select/poll底层数据结构差异: select/poll (Java NIO 在 Linux 上的默认实现): ┌────────────────────────────────┐ │ 每次调用: │ │ 1. 把所有 fd 拷贝到内核 │ ← O(n) 拷贝 │ 2. 遍历所有 fd 检查就绪 │ ← O(n) 遍历 │ 3. 返回就绪 fd 数量 │ │ fd 数量限制: select1024 │ └────────────────────────────────┘ epoll (Java NIO 在 Linux 上可配置使用): ┌────────────────────────────────┐ │ 事件驱动: │ │ 1. 注册 fd 到 epoll 实例 │ ← O(1) 注册 │ 2. 内核通过回调通知就绪 fd │ ← O(1) 通知 │ 3. 只返回就绪 fd 列表 │ ← O(就绪数) │ fd 数量无限制 │ └────────────────────────────────┘ 性能差异: 10000 连接, 10 个活跃: select: 遍历 10000 个 fd epoll: 只处理 10 个就绪 fd四、Java AIO异步 I/O// AIO (JDK 7): 真正的异步 I/O// 内核完成数据读取后回调通知publicclassAioServer{publicstaticvoidmain(String[]args)throwsIOException{AsynchronousServerSocketChannelserverAsynchronousServerSocketChannel.open().bind(newInetSocketAddress(8080));server.accept(null,newCompletionHandlerAsynchronousSocketChannel,Void(){Overridepublicvoidcompleted(AsynchronousSocketChannelclient,Voidattachment){server.accept(null,this);// 接受下一个连接ByteBufferbufByteBuffer.allocate(1024);client.read(buf,buf,newCompletionHandlerInteger,ByteBuffer(){Overridepublicvoidcompleted(Integerlen,ByteBufferbuf){buf.flip();client.write(buf);}Overridepublicvoidfailed(Throwableexc,ByteBufferbuf){}});}Overridepublicvoidfailed(Throwableexc,Voidattachment){}});// 主线程不阻塞AIO 由内核线程池完成Thread.currentThread().join();}}AIO 实现差异: Linux: epoll 模拟异步 (不是真正的 AIO) Windows: IOCP (真正的异步 I/O) → Java AIO 在 Linux 上性能不如 NIO → 这就是为什么 Netty 选择了 NIO 而不是 AIO → Netty 官方曾尝试支持 AIO 但最终放弃五、三种 IO 对比对比维度BIONIOAIO通信模型阻塞非阻塞异步连接管理一连接一线程一线程管多连接回调驱动数据流单向流双向 Buffer双向 Buffer并发能力低1000高10000高10000编程复杂度简单复杂中等Linux 底层阻塞 I/Oepollepoll 模拟代表框架Tomcat BIONetty/MinaJDK AIO六、零拷贝零拷贝是减少数据在内核态和用户态之间拷贝次数的技术传统数据传输 (4次拷贝 4次上下文切换): 磁盘 ──DMA拷贝──▶ 内核缓冲区 ──CPU拷贝──▶ 用户缓冲区 ↓ CPU拷贝 Socket缓冲区 ──DMA拷贝──▶ 网卡 ←──────┘ 1. DMA拷贝: 磁盘→内核读缓冲区 (0次上下文切换) 2. CPU拷贝: 内核读缓冲区→用户缓冲区 (切换到用户态) 3. CPU拷贝: 用户缓冲区→Socket缓冲区 (切换到内核态) 4. DMA拷贝: Socket缓冲区→网卡 (切换回来) mmap (3次拷贝 4次切换): 磁盘 ──DMA拷贝──▶ 内核缓冲区 ↓ 内存映射(0拷贝) 用户空间映射 ──────────┘ ↓ CPU拷贝 Socket缓冲区 ──DMA拷贝──▶ 网卡 sendfile (2次拷贝 2次切换): 磁盘 ──DMA拷贝──▶ 内核缓冲区 ──DMA拷贝──▶ 网卡 (完全绕过用户空间0次CPU拷贝) Linux 2.4 sendfile: SG-DMA 磁盘 ──DMA拷贝──▶ 内核缓冲区 ──DMA─SG─▶ 网卡 (真正的零拷贝: 0次CPU拷贝)Java 中的零拷贝// 1. MappedByteBuffer (mmap)FileChannelfcnewRandomAccessFile(file.txt,r).getChannel();MappedByteBuffermbbfc.map(FileChannel.MapMode.READ_ONLY,0,fc.size());// 文件直接映射到用户空间内存无需拷贝// 2. FileChannel.transferTo (sendfile)FileChannelinnewFileInputStream(file.txt).getChannel();FileChanneloutnewFileOutputStream(copy.txt).getChannel();in.transferTo(0,in.size(),out);// 内核直接从源文件拷贝到目标文件绕过用户空间// 3. Netty 中的零拷贝// - CompositeByteBuf: 多个 Buffer 合并无需拷贝// - Unpooled.wrappedBuffer(): 包装数组不拷贝// - FileRegion: 底层使用 transferToByteBufheaderUnpooled.buffer(10);ByteBufbodyUnpooled.buffer(90);ByteBufallUnpooled.wrappedBuffer(header,body);// 零拷贝合并零拷贝技术对比: 传统: 磁盘→内核→用户→Socket→网卡 (4次拷贝) mmap: 磁盘→内核→(映射)→Socket→网卡 (3次拷贝) sendfile: 磁盘→内核→网卡 (2次拷贝) SG-DMA: 磁盘→内核→网卡 (0次CPU拷贝, 真正零拷贝)七、NettyNIO 的工程化封装// Netty 服务端publicclassNettyServer{publicstaticvoidmain(String[]args)throwsException{EventLoopGroupbossGroupnewNioEventLoopGroup(1);// AcceptEventLoopGroupworkerGroupnewNioEventLoopGroup();// Read/WriteServerBootstrapbnewServerBootstrap();b.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(newChannelInitializerSocketChannel(){OverrideprotectedvoidinitChannel(SocketChannelch){ch.pipeline().addLast(newStringDecoder()).addLast(newStringEncoder()).addLast(newSimpleChannelInboundHandlerString(){OverrideprotectedvoidchannelRead0(ChannelHandlerContextctx,Stringmsg){System.out.println(收到: msg);ctx.writeAndFlush(echo: msg);}});}});ChannelFuturefb.bind(8080).sync();f.channel().closeFuture().sync();}}Netty Reactor 模型: ┌───────────────────────────────────────────────┐ │ Main Reactor (BossGroup) │ │ ┌─────────────┐ │ │ │ Acceptor │ │ │ └──────┬──────┘ │ │ │ 分发连接 │ │ ┌────────────────┼────────────────┐ │ │ ▼ ▼ ▼ │ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │ │Sub │ │Sub │ │Sub │ │ │ │Reactor│ │Reactor│ │Reactor│ │ │ │(Worker)│ │(Worker)│ │(Worker)│ │ │ └──┬───┘ └──┬───┘ └──┬───┘ │ │ │ │ │ │ │ ▼ ▼ ▼ │ │ Pipeline Pipeline Pipeline │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │Decoder │ │Decoder │ │Decoder │ │ │ │Handler │ │Handler │ │Handler │ │ │ │Encoder │ │Encoder │ │Encoder │ │ │ └──────────┘ └──────────┘ └──────────┘ │ └───────────────────────────────────────────────┘ Boss: 接受连接 → 分配给 Worker Worker: 处理 I/O → 走 Pipeline → 业务 HandlerNetty 核心设计Netty 为什么快: 1. Reactor 线程模型 → 避免锁竞争 2. 零拷贝 → CompositeByteBuf/FileRegion 3. 无锁化串行设计 → 同一 Channel 的所有操作在同一个线程 4. ByteBuf 池化 → 减少 GC 压力 5. 高性能序列化 → 内置多种编解码器 6. 可扩展的 Pipeline → 责任链模式 主线程 Reactor 模型 (Netty 3): 单线程处理 Accept Read/Write 从线程 Reactor 模型 (Netty 4): Boss 线程: Accept Worker 线程: Read/Write 业务处理 同一 Channel 绑定同一 EventLoop → 无锁串行八、常见面试追问Q1NIO 一定比 BIO 快吗不一定。在连接数少且活跃的场景BIO 的简单实现反而更快没有 Selector 的开销。NIO 的优势在于连接数多但活跃度低如 IM 长连接一个线程管理多个连接。Q2select、poll、epoll 的区别select: fd 数组有 1024 限制每次调用需拷贝全部 fdO(n) 遍历poll: 无 fd 数量限制但仍然 O(n) 遍历epoll: 事件驱动只返回就绪 fdO(1) 效率fd 无限制Q3Netty 为什么不使用 AIOLinux AIO 不成熟底层仍用 epoll 模拟没有性能优势AIO 的回调模型编程复杂Netty 在 NIO 上已充分优化性能足够好Netty 5 曾尝试支持 AIO但因性能收益不大最终放弃Q4ByteBuf 和 ByteBuffer 的区别ByteBuffer: 固定长度position/limit 状态管理复杂不动态扩容ByteBuf: 动态扩容读写指针独立不需要 flip支持池化支持零拷贝CompositeByteBuf九、总结IO 演进链路: BIO (阻塞, 一连接一线程) ↓ 突破 C10K NIO (非阻塞 多路复用, 一线程管多连接) ↓ 工程化封装 Netty (Reactor Pipeline 零拷贝 池化) ↓ 异步化 AIO (内核回调, Linux 上用 epoll 模拟) 底层核心: epoll (I/O 多路复用) sendfile/mmap (零拷贝) Java 核心: Channel Buffer Selector Netty 核心: EventLoop Pipeline ByteBuf理解 IO 模型的演进核心是理解操作系统层面的 I/O 模型差异。Java 的 IO API 只是对操作系统接口的封装真正决定性能的是 epoll 和零拷贝等底层技术。