前言

在Java网络编程和高性能服务器开发中，I/O模型的选择直接影响着系统的并发处理能力、资源利用效率和整体性能表现。随着互联网应用规模的不断扩大，传统的同步阻塞I/O（BIO）已难以满足高并发场景的需求，而同步非阻塞I/O（NIO）和异步非阻塞I/O（AIO）则提供了更高效的解决方案。

本文旨在系统性地介绍Java中三种主要的I/O模型：BIO、NIO和AIO，深入剖析它们的工作原理、核心组件、适用场景以及在实际开发中的实现方式。通过对比分析这三种模型的优缺点，帮助开发者根据具体业务需求选择最合适的I/O模型，构建高性能、高可用的网络应用系统。

IO的方式通常分为几种：同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。

一、BIO（同步阻塞IO）

在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信。默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程响应，如果没有则会一直等待或者遭到拒绝请求，如果有的话，客户端线程会等待请求结束后才继续执行。

二、NIO（同步非阻塞IO）

2.1 NIO的核心思想

NIO本身是基于事件驱动思想来完成的，其主要想解决的是BIO的大并发问题。在使用同步I/O的网络应用中，如果要同时处理多个客户端请求，或是在客户端要同时和多个服务器进行通讯，就必须使用多线程来处理。也就是说，将每一个客户端请求分配给一个线程来单独处理。这样做虽然可以达到我们的要求，但同时又会带来另外一个问题。由于每创建一个线程，就要为这个线程分配一定的内存空间（也叫工作存储器），而且操作系统本身也对线程的总数有一定的限制。如果客户端的请求过多，服务端程序可能会因为不堪重负而拒绝客户端的请求，甚至服务器可能会因此而瘫痪。

2.2 Reactor模式与NIO

NIO基于Reactor模式，当socket有流可读或可写入socket时，操作系统会相应的通知应用程序进行处理，应用再将流读取到缓冲区或写入操作系统。也就是说，这个时候，已经不是一个连接就要对应一个处理线程了，而是有效的请求对应一个线程，当连接没有数据时，是没有工作线程来处理的。

2.3 BIO与NIO的线程模型对比

BIO与NIO一个比较重要的不同，是我们使用BIO的时候往往会引入多线程，每个连接一个单独的线程；而NIO则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。

2.4 NIO的多路复用机制

NIO的最重要的地方是当一个连接创建后，不需要对应一个线程，这个连接会被注册到多路复用器上面，所以所有的连接只需要一个线程就可以搞定。当这个线程中的多路复用器进行轮询的时候，发现连接上有请求的话，才开启一个线程进行处理，也就是一个请求一个线程模式。

2.5 NIO的潜在问题

在NIO的处理方式中，当一个请求来的话，开启线程进行处理，可能会等待后端应用的资源（JDBC连接等），其实这个线程就被阻塞了，当并发上来的话，还是会有BIO一样的问题。

2.6 HTTP长连接与NIO的优化

HTTP/1.1出现后，有了Http长连接，这样除了超时和指明特定关闭的http header外，这个链接是一直打开的状态的。这样在NIO处理中可以进一步的进化，在后端资源中可以实现资源池或者队列，当请求来的话，开启的线程把请求和请求数据传送给后端资源池或者队列里面就返回，并且在全局的地方保持住这个现场（哪个连接的哪个请求等）。这样前面的线程还是可以去接受其他的请求，而后端的应用的处理只需要执行队列里面的就可以了，这样请求处理和后端应用是异步的。当后端处理完，到全局地方得到现场，产生响应，这个就实现了异步处理。

三、AIO（异步非阻塞IO）

3.1 AIO的基本原理

与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可。这两种方法均为异步的：

  • 对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序
  • 对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序

即可以理解为，read/write方法都是异步的，完成后会主动调用回调函数。

3.2 JDK中的AIO支持

在JDK1.7中，这部分内容被称作NIO.2，主要在java.nio.channels包下增加了下面四个异步通道：

  • AsynchronousSocketChannel
  • AsynchronousServerSocketChannel
  • AsynchronousFileChannel
  • AsynchronousDatagramChannel

其中的read/write方法，会返回一个带回调函数的对象，当执行完读取/写入操作后，直接调用回调函数。

四、三种IO模型的对比总结

4.1 核心区别

  • BIO：一个连接一个线程
  • NIO：一个请求一个线程
  • AIO：一个有效请求一个线程

4.2 银行取款类比理解

先来个例子理解一下概念，以银行取款为例：

  • 同步：自己亲自出马持银行卡到银行取钱（使用同步IO时，Java自己处理IO读写）
  • 异步：委托一小弟拿银行卡到银行取钱，然后给你（使用异步IO时，Java将IO读写委托给OS处理，需要将数据缓冲区地址和大小传给OS（银行卡和密码），OS需要支持异步IO操作API）
  • 阻塞：ATM排队取款，你只能等待（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）
  • 非阻塞：柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排到了没有，大堂经理如果说还没到你就不能去（使用非阻塞IO时，如果不能读写Java调用会马上返回，当IO事件分发器会通知可读写时再继续进行读写，不断循环直到读写完成）

4.3 Java对三种IO模型的支持

  • Java BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
  • Java NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
  • Java AIO（NIO.2）：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

4.4 代码示例：三种IO模型的Java实现

下面分别展示BIO、NIO和AIO创建服务器端的最小示例代码：

BIO示例（同步阻塞IO）
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class BioServer {
    public static void main(String[] args) throws IOException {
        // 创建ServerSocket监听8080端口
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO服务器启动，监听端口: 8080");
        
        while (true) {
            // accept()会阻塞，直到有客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("接收到客户端连接: " + socket.getInetAddress());
            
            // 为每个连接创建新线程处理
            new Thread(() -> {
                try {
                    InputStream input = socket.getInputStream();
                    byte[] buffer = new byte[1024];
                    int len;
                    // read()会阻塞，直到有数据可读
                    while ((len = input.read(buffer)) != -1) {
                        System.out.println("收到数据: " + new String(buffer, 0, len));
                    }
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
NIO示例（同步非阻塞IO）
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 = Selector.open();
        // 创建ServerSocketChannel并设置为非阻塞模式
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8080));
        // 将ServerSocketChannel注册到Selector，监听ACCEPT事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NIO服务器启动，监听端口: 8080");
        
        while (true) {
            // select()会阻塞，直到有事件就绪
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();
                
                if (key.isAcceptable()) {
                    // 处理新连接
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    // 将新连接注册到Selector，监听READ事件
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("接收到新连接: " + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 处理读事件
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int len = client.read(buffer);
                    if (len > 0) {
                        buffer.flip();
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        System.out.println("收到数据: " + new String(data));
                    } else if (len == -1) {
                        client.close();
                    }
                }
            }
        }
    }
}
AIO示例（异步非阻塞IO）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class AioServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 创建AsynchronousServerSocketChannel
        AsynchronousServerSocketChannel serverChannel = 
            AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        System.out.println("AIO服务器启动，监听端口: 8080");
        
        // 异步接受连接，使用CompletionHandler处理连接完成事件
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Void attachment) {
                // 继续接受下一个连接
                serverChannel.accept(null, this);
                
                // 处理当前连接
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                // 异步读取数据
                client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer buffer) {
                        if (result > 0) {
                            buffer.flip();
                            byte[] data = new byte[buffer.remaining()];
                            buffer.get(data);
                            System.out.println("收到数据: " + new String(data));
                        }
                        try {
                            client.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    
                    @Override
                    public void failed(Throwable exc, ByteBuffer buffer) {
                        exc.printStackTrace();
                        try {
                            client.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
            
            @Override
            public void failed(Throwable exc, Void attachment) {
                exc.printStackTrace();
            }
        });
        
        // 保持主线程运行
        Thread.currentThread().join();
    }
}

代码说明：

  • BIO示例：使用ServerSocket和Socket，每个连接创建一个新线程，accept()和read()都是阻塞调用。
  • NIO示例：使用Selector多路复用器，单线程处理多个连接，通过事件驱动方式处理连接和读写。
  • AIO示例：使用AsynchronousServerSocketChannel，通过CompletionHandler回调处理连接和读写，完全异步非阻塞。

4.4 适用场景分析

  • BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
  • NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
  • AIO方式适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

五、深入理解IO模型

5.1 操作系统层面的考虑

另外，I/O属于底层操作，需要操作系统支持，并发也需要操作系统的支持，所以性能方面不同操作系统差异会比较明显。

5.2 Reactor与Proactor模式

在高性能的I/O设计中，有两个比较著名的模式Reactor和Proactor模式，其中Reactor模式用于同步I/O，而Proactor运用于异步I/O操作。

下面通过流程图展示这两种模式的核心组件与数据流向：

Reactor模式（同步I/O）流程图

flowchart TD
    subgraph Reactor模式
        A[客户端请求] --> B[Initiation Dispatcher
事件分发器]
        B --> C[Handle
资源句柄]
        C --> D[Synchronous Event Demultiplexer
同步事件多路分离器]
        D -->|等待事件就绪| E[Event Handler
事件处理器]
        E -->|处理就绪事件| F[Concrete Event Handler
具体事件处理器]
        F -->|执行实际I/O操作| G[返回结果]
        
        style A fill:#e1f5fe
        style B fill:#f3e5f5
        style C fill:#e8f5e8
        style D fill:#fff3e0
        style E fill:#fce4ec
        style F fill:#e8eaf6
        style G fill:#f1f8e9
    end

图注说明：Reactor模式采用同步I/O，核心组件包括事件分发器、同步事件多路分离器和事件处理器。工作流程：1) 客户端请求注册到事件分发器；2) 同步事件多路分离器等待I/O事件就绪；3) 事件就绪后，分发器调用对应的事件处理器；4) 具体事件处理器执行实际的I/O操作。

Proactor模式（异步I/O）流程图
flowchart TD
    subgraph Proactor模式
        A[客户端请求] --> B[Asynchronous Operation Processor
异步操作处理器]
        B --> C[发起异步I/O操作]
        C --> D[操作系统内核]
        D -->|I/O操作完成| E[Completion Dispatcher
完成分发器]
        E --> F[Completion Handler
完成处理器]
        F --> G[Proactor
主动器]
        G --> H[返回结果]
        
        style A fill:#e1f5fe
        style B fill:#f3e5f5
        style C fill:#e8f5e8
        style D fill:#fff3e0
        style E fill:#fce4ec
        style F fill:#e8eaf6
        style G fill:#f1f8e9
        style H fill:#fff8e1
    end

图注说明：Proactor模式采用异步I/O，核心组件包括异步操作处理器、完成分发器和完成处理器。工作流程：1) 客户端请求到达异步操作处理器；2) 处理器发起异步I/O操作给操作系统内核；3) 内核完成I/O操作后通知完成分发器；4) 分发器调用对应的完成处理器；5) 完成处理器将结果交给Proactor主动器处理。

两种模式对比
  • Reactor模式：同步I/O，应用程序主动等待事件就绪，然后执行I/O操作。适用于连接数多但每个连接数据量不大的场景。
  • Proactor模式：异步I/O，应用程序发起I/O操作后立即返回，由操作系统完成I/O操作后通知应用程序。适用于连接数多且每个连接数据量大的场景。
  • 关键区别：Reactor模式中应用程序执行实际的I/O操作，而Proactor模式中操作系统执行实际的I/O操作。

5.3 阻塞/非阻塞与同步/异步的概念澄清

在比较这两个模式之前，我们首先的搞明白几个概念：

  • 同步和异步是针对应用程序和内核的交互而言的：
    • 同步：用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪
    • 异步：用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知
  • 阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作函数的实现方式：
    • 阻塞方式下读取或者写入函数将一直等待
    • 非阻塞方式下，读取或者写入函数会立即返回一个状态值

5.4 四种IO模型分类

一般来说I/O模型可以分为：同步阻塞，同步非阻塞，异步阻塞，异步非阻塞IO

5.4.1 同步阻塞IO

在此种方式下，用户进程在发起一个IO操作以后，必须等待IO操作的完成，只有当真正完成了IO操作以后，用户进程才能运行。JAVA传统的IO模型属于此种方式！

5.4.2 同步非阻塞IO

在此种方式下，用户进程发起一个IO操作以后边可返回做其它事情，但是用户进程需要时不时的询问IO操作是否就绪，这就要求用户进程不停的去询问，从而引入不必要的CPU资源浪费。其中目前JAVA的NIO就属于同步非阻塞IO。

5.4.3 异步阻塞IO

此种方式下是指应用发起一个IO操作以后，不等待内核IO操作的完成，等内核完成IO操作以后会通知应用程序，这其实就是同步和异步最关键的区别，同步必须等待或者主动的去询问IO是否完成。那么为什么说是阻塞的呢？因为此时是通过select系统调用来完成的，而select函数本身的实现方式是阻塞的，而采用select函数有个好处就是它可以同时监听多个文件句柄，从而提高系统的并发性！

5.4.4 异步非阻塞IO

在此种模式下，用户进程只需要发起一个IO操作然后立即返回，等IO操作真正的完成以后，应用程序会得到IO操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的IO读写操作，因为真正的IO读取或者写入操作已经由内核完成了。

总结

通过对BIO、NIO和AIO三种I/O模型的深入分析，我们可以得出以下结论：

技术演进趋势

  • BIO（同步阻塞I/O）：作为Java最早的I/O模型，实现简单直观，适合连接数较少且固定的场景，但线程资源消耗大，不适合高并发环境。
  • NIO（同步非阻塞I/O）：基于事件驱动和多路复用机制，显著提升了系统的并发处理能力，适合连接数多但每个连接数据量不大的场景，如聊天服务器、即时通讯等。
  • AIO（异步非阻塞I/O）：真正意义上的异步I/O，由操作系统完成I/O操作后回调通知应用程序，适合连接数多且每个连接数据量大的场景，如文件服务器、相册服务等。

选择建议

  1. 简单应用场景：如果应用连接数较少（如内部管理系统、小型网站），BIO因其简单性仍是合适选择。
  2. 高并发短连接：对于需要处理大量短连接的应用（如即时通讯、API网关），NIO的多路复用特性能够显著提升性能。
  3. 高并发长连接大数据量：对于需要处理大量长连接且数据传输量大的应用（如文件传输、视频流服务），AIO能够充分利用操作系统能力，提供最佳性能。
  4. 技术栈考虑：NIO在JDK1.4引入，AIO在JDK1.7引入，需要考虑目标环境的JDK版本支持情况。

实践建议

  • 理解底层原理比单纯使用框架更重要，掌握Reactor和Proactor模式有助于设计更合理的系统架构。
  • 在实际项目中，Netty、Mina等NIO框架已经对底层NIO进行了良好封装，提供了更易用的API和更完善的生态。
  • 性能测试是选择I/O模型的关键环节，应在真实业务场景下进行压力测试，根据实际表现做出决策。
  • 监控和调优同样重要，需要关注线程池配置、缓冲区大小、连接超时等参数的优化。

总之，没有一种I/O模型能够适用于所有场景。开发者需要根据具体的业务需求、性能要求、团队技术栈和运维能力，选择最合适的I/O模型。随着技术的不断发展，新的I/O模型和优化策略也在不断涌现，保持学习和实践是提升系统性能的关键。

Logo
openEuler 社区

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目，面向数字基础设施四大核心场景（服务器、云计算、边缘计算、嵌入式），全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐

cover

计算机组成原理：从晶体管到你面前这块屏幕的史诗之旅

avatar openEuler 社区

百度网盘不限速下载工具盘点：2026最新PanDownload配置与加速技巧

原因分析：相比于单个体积较大的文件，成百上千个微小文件在传输时需要频繁建立连接并进行分散存储，这会极大消耗系统的处理效率，导致整体速率明显偏低。原因分析：操作系统在后台静默运行的系统更新、自动同步工具以及多媒体程序，都会在不知不觉中分流带宽，导致网盘程序分配到的网络份额变小。建议方法：在上传或保存前，先在云端将大量分散的小文件打包装入压缩包中，以单个完整文件的形式进行传输，完成后再解压使用。建议方

avatar openEuler 社区
cover

同为23.8寸触控一体机，畅想视界凭什么更懂行业需求

avatar openEuler 社区