肖哥弹架构 跟大家“弹弹” BIO/NIO/AIO设计与实战应用，需要代码关注

欢迎 关注，点赞，留言。

关注公号Solomon肖哥弹架构获取更多精彩内容

历史热点文章

• MyCat应用实战：分布式数据库中间件的实践与优化（篇幅一）
• 图解深度剖析：MyCat 架构设计与组件协同 （篇幅二）
• 一个项目代码讲清楚DO/PO/BO/AO/E/DTO/DAO/ POJO/VO
• 写代码总被Dis：5个项目案例带你掌握SOLID技巧,代码有架构风格
• 里氏替换原则在金融交易系统中的实践，再不懂你咬我

从阻塞式BIO到零拷贝NIO，再到异步AIO，一文搞懂Java高并发I/O的底层原理与实战优化。包含多路复用、内存映射、Selector事件驱动等硬核技术，搭配代码对比+性能数据，带你彻底告别线程阻塞和资源浪费！无论是面试突击还是项目优化，这份指南都能让你快人一步。

一、BIO（Blocking I/O）详解

Java BIO（Blocking I/O，阻塞式 I/O）是 Java 最基础的 I/O 模型，采用同步阻塞的方式处理数据流，适用于简单、低并发的场景。

1. BIO 核心特点

1.1 阻塞式模型

• 线程阻塞：每个 I/O 操作（如 read()、write()）都会阻塞当前线程，直到数据就绪。
• 一连接一线程：每个客户端连接需要独立的线程处理，高并发时资源消耗大。

1.2 核心类

• InputStream / OutputStream：字节流读写。
• Reader / Writer：字符流读写。
• ServerSocket / Socket：TCP 网络通信。

2. BIO 工作机制

3. 代码片段

3.1 BIO 服务器（单线程阻塞）

ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    Socket socket = serverSocket.accept(); // 阻塞等待连接
    InputStream in = socket.getInputStream();
    byte[] buffer = new byte[1024];
    int len = in.read(buffer); // 阻塞读取数据
    System.out.println("收到数据: " + new String(buffer, 0, len));
    socket.close();
}

3.2 BIO 服务器（线程池优化）

ExecutorService threadPool = Executors.newFixedThreadPool(10);
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    Socket socket = serverSocket.accept();
    threadPool.execute(() -> {
        try {
            InputStream in = socket.getInputStream();
            byte[] buffer = new byte[1024];
            int len = in.read(buffer); // 阻塞读取
            System.out.println("处理数据: " + new String(buffer, 0, len));
        } catch (IOException e) {
            e.printStackTrace();
        }
    });
}

4. BIO 的优缺

4.1 优点

✅ 简单易用：代码直观，适合快速开发。
✅ 兼容性好：所有 Java 版本和操作系统支持。

4.2 缺点

❌ 性能瓶颈：线程数随连接数线性增长，高并发时资源耗尽。
❌ 扩展性差：不适合长连接或高吞吐场景。

5. 使用场景

5.1 适合 BIO 的场景

✔ 低并发应用：小型 HTTP 服务、本地文件处理。
✔ 快速原型开发：验证逻辑时无需复杂设计。

5.2 不适合 BIO 的场景

❌ 高并发服务器（如聊天室、游戏后端）。
❌ 长连接服务（如实时数据推送）。

6. 小结

• BIO 是同步阻塞模型，适合简单、低并发的场景。
• 缺点明显：线程资源消耗大，需用线程池优化。
• 升级建议：高并发场景优先选择 NIO（如 Netty）或 AIO。

📌 现代开发推荐：直接使用 Netty（基于 NIO 的高性能框架），避免手动管理线程和阻塞问题。

二、NIO（New I/O）详解

Java NIO（New I/O）是 Java 1.4 引入的非阻塞式 I/O 模型，相比传统的 java.io（阻塞式流式 I/O），它提供了更高效的缓冲区（Buffer）、通道（Channel）、选择器（Selector） 机制，适合高并发网络编程和大文件处理。

图说明

1. Selector（选择器）
   • 核心多路复用器，监听多个 Channel 的 就绪事件（OP_READ/OP_WRITE等）。
   • 通过 select() 阻塞直到至少一个 Channel 就绪。
2. Channel（通道）
   • 双向数据管道（支持读/写），需配置为非阻塞模式：

     channel.configureBlocking(false);
     

   • 类型：SocketChannel、ServerSocketChannel、DatagramChannel。
3. Buffer（缓冲区）
   • 数据中转站，通过 put()/get()读写，需手动flip()` 切换模式。
4. 与传统 BIO 对比
   • NIO 单线程可处理多连接，BIO 需为每个连接创建线程。

1. Java NIO 核心组件

1.1 Buffer（缓冲区）

• 作用：临时存储数据（类似数组，但更高效）。
• 类型：ByteBuffer（最常用）、CharBuffer、IntBuffer 等。
• 关键操作：
  • put() / get()：写入/读取数据。
  • flip()：切换读写模式（写 → 读）。
  • clear() / compact()：清空或压缩缓冲区。

代码片段：

ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配 1KB 缓冲区
buffer.put("你好".getBytes(StandardCharsets.UTF_8)); // 写入数据
buffer.flip(); // 切换为读模式
while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get()); // 逐个字节读取
}

1.2 Channel（通道）

• 作用：连接数据源（文件、网络套接字），支持非阻塞读写。
• 常见实现：
  • FileChannel：文件读写。
  • SocketChannel / ServerSocketChannel：TCP 通信。
  • DatagramChannel：UDP 通信。

1.2.1 FileChannel

代码片段（文件复制） ：

try (FileChannel srcChannel = FileChannel.open(Paths.get("source.txt"));
     FileChannel destChannel = FileChannel.open(Paths.get("target.txt"), 
          StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    srcChannel.transferTo(0, srcChannel.size(), destChannel); // 零拷贝高效传输
}

1.2.2 DatagramChannel：UDP 通信

DatagramChannel 是 Java NIO 提供的非阻塞 UDP 通信实现，相比传统 DatagramSocket，它支持 Selector 多路复用，适合高性能 UDP 应用（如视频流、游戏同步、DNS 查询）。

1. 核心特性

• 非阻塞模式：可注册到 Selector 实现多路复用。
• 直接缓冲区支持：零拷贝优化（ByteBuffer.allocateDirect）。
• 面向数据报：无需建立连接，直接发送/接收数据包。

2. 代码片段

2.1 UDP 服务端（接收数据）

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;

public class UDPServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建 DatagramChannel 并绑定端口
        DatagramChannel serverChannel = DatagramChannel.open();
        serverChannel.bind(new InetSocketAddress(9999)); // 绑定 UDP 端口

        System.out.println("UDP 服务端启动，监听 9999 端口...");

        // 2. 创建缓冲区接收数据
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (true) {
            // 3. 接收数据包（非阻塞模式下需检查返回值）
            InetSocketAddress clientAddress = (InetSocketAddress) serverChannel.receive(buffer);

            if (clientAddress != null) {
                buffer.flip(); // 切换为读模式
                byte[] data = new byte[buffer.remaining()];
                buffer.get(data); // 读取数据到字节数组
                System.out.println("收到来自 " + clientAddress + " 的消息: " + new String(data));
                buffer.clear(); // 清空缓冲区，准备下次接收
            }
        }
    }
}

2.2 UDP 客户端（发送数据）

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.charset.StandardCharsets;

public class UDPClient {
    public static void main(String[] args) throws IOException {
        // 1. 创建 DatagramChannel（无需绑定端口）
        DatagramChannel clientChannel = DatagramChannel.open();

        // 2. 准备发送的数据
        String message = "Hello, UDP Server!";
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));

        // 3. 发送数据到服务端
        clientChannel.send(buffer, new InetSocketAddress("localhost", 9999));
        System.out.println("消息已发送: " + message);

        clientChannel.close(); // 关闭通道
    }
}

3. 高级用法：非阻塞模式 + Selector

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class UDPNonBlockingServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建 DatagramChannel 并设置为非阻塞模式
        DatagramChannel channel = DatagramChannel.open();
        channel.bind(new InetSocketAddress(9999));
        channel.configureBlocking(false);

        // 2. 创建 Selector 并注册读事件
        Selector selector = Selector.open();
        channel.register(selector, SelectionKey.OP_READ);

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (true) {
            selector.select(); // 阻塞直到有事件就绪
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iter = keys.iterator();

            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();

                if (key.isReadable()) {
                    // 3. 处理 UDP 数据包
                    DatagramChannel udpChannel = (DatagramChannel) key.channel();
                    InetSocketAddress clientAddress = (InetSocketAddress) udpChannel.receive(buffer);

                    if (clientAddress != null) {
                        buffer.flip();
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        System.out.println("收到数据: " + new String(data));
                        buffer.clear();
                    }
                }
            }
        }
    }
}

4. 关键点说明

1. 绑定端口：服务端需调用 bind()，客户端通常不需要。
2. 缓冲区复用：每次接收后需 clear() 缓冲区。
3. 非阻塞模式：
   • configureBlocking(false) 启用非阻塞。
   • 结合 Selector 实现多路复用（参考 NIO 的 TCP 用法）。
4. 数据包无连接：UDP 不保证顺序和可靠性，需应用层处理。

5. 适用场景

✔ 实时性要求高：音视频流、游戏同步。
✔ 轻量级通信：DNS 查询、状态心跳。
✔ 广播/组播：向多个客户端发送相同数据。

📌 注意：若需可靠传输，建议在应用层实现重传机制（如 QUIC 协议）。

1.3 Selector（选择器）

• 作用：单线程管理多个 Channel，实现多路复用 I/O（类似 epoll）。
• 适用场景：高并发服务器（如聊天室、游戏服务器）。
• 事件类型：
  • OP_READ：可读事件。
  • OP_WRITE：可写事件。
  • OP_CONNECT：连接就绪。
  • OP_ACCEPT：接受新连接。

代码片段（简易非阻塞服务器） ：

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false); // 非阻塞模式
serverChannel.register(selector, SelectionKey.OP_ACCEPT); // 注册 accept 事件

while (true) {
    selector.select(); // 阻塞等待事件
    Set<SelectionKey> keys = selector.selectedKeys();
    for (SelectionKey key : keys) {
        if (key.isAcceptable()) { // 有新连接
            SocketChannel client = serverChannel.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ); // 监听读事件
        } else if (key.isReadable()) { // 可读数据
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(128);
            client.read(buffer);
            buffer.flip();
            client.write(buffer); // 回显数据
        }
    }
    keys.clear();
}

1.5 MappedByteBuffer(内存映射文件)

MappedByteBuffer 是 Java NIO 提供的一种 内存映射文件 技术，允许将文件直接映射到进程的虚拟内存空间，从而绕过传统的 read()/write() 系统调用，实现 零拷贝 的高效文件访问。特别适合处理 大文件随机访问 或 高频读写 场景。

1.5.1 工作原理

1.5.2 基础读写操作

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MappedFileExample {
    public static void main(String[] args) throws Exception {
        // 1. 打开文件并获取通道
        RandomAccessFile file = new RandomAccessFile("test.dat", "rw");
        FileChannel channel = file.getChannel();

        // 2. 将文件映射到内存（模式：READ_WRITE，映射区域：0~1024字节）
        MappedByteBuffer buffer = channel.map(
            FileChannel.MapMode.READ_WRITE,  // 读写模式
            0,                             // 起始位置
            1024                           // 映射大小
        );

        // 3. 写入数据（直接操作内存）
        buffer.put("Hello, MappedByteBuffer!".getBytes());

        // 4. 读取数据
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        System.out.println(new String(data));

        // 5. 关闭资源（buffer变化会自动同步到文件）
        channel.close();
        file.close();
    }
}

1.5.3 大文件分块映射

// 分块处理大文件（避免一次性映射整个文件）
long fileSize = channel.size();
long chunkSize = 1024 * 1024; // 1MB 分块
long position = 0;

while (position < fileSize) {
    long remaining = fileSize - position;
    long size = Math.min(chunkSize, remaining);
    MappedByteBuffer chunk = channel.map(
        FileChannel.MapMode.READ_WRITE,
        position,
        size
    );
    // 处理当前分块...
    position += size;
}

1.5.4 性能优化技巧

(1) 使用 DirectByteBuffer

// 显式使用直接缓冲区（减少一次拷贝）
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);
channel.read(directBuffer);

(2) 手动强制刷盘

MappedByteBuffer buffer = channel.map(...);
buffer.put(...);
buffer.force(); // 强制将更改写入磁盘（类似 fsync）

(3) 避免频繁映射/解除映射

• 频繁调用 map()/unmap() 会导致性能下降，尽量 复用已映射的缓冲区。

1.5.5 适用场景

推荐使用场景

✔ 大文件随机读写（如数据库索引文件）。
✔ 高频读写日志（如 Kafka 的 commit log）。
✔ 进程间共享内存（需配合文件锁）。

不适用场景

❌ 小文件处理（传统 I/O 更简单）。
❌ 只读且顺序访问的文件（Files.readAllBytes() 更高效）。

1.5.6 底层原理

操作系统支持

• Linux/Unix：通过 mmap() 系统调用实现。
• Windows：通过 CreateFileMapping/MapViewOfFile 实现。

内存同步机制

• 写入：修改 MappedByteBuffer 后，OS 异步将脏页写回磁盘（调用 force() 可强制同步）。
• 读取：OS 自动按需加载文件内容到页缓存。

1.5.7 注意事项

1. 资源释放：
   • MappedByteBuffer 本身无 close() 方法，需通过 FileChannel 或 RandomAccessFile 关闭。
   • 解除映射依赖 GC 或手动调用 Cleaner（较复杂，通常无需处理）。
2. 线程安全：
   • 多线程操作同一 MappedByteBuffer 需自行同步（如 synchronized）。
3. 虚拟内存限制：
   • 避免映射超过物理内存的文件，否则可能触发频繁缺页中断。

1.5.8 性能对比

// 传统 I/O
FileInputStream fis = new FileInputStream("largefile.bin");
byte[] data = new byte[1024];
while (fis.read(data) != -1) { /* 处理数据 */ }

// MappedByteBuffer
MappedByteBuffer buffer = channel.map(MapMode.READ_ONLY, 0, channel.size());
while (buffer.hasRemaining()) { 
    byte b = buffer.get(); // 直接内存访问
}

• 测试结果：对于 1GB 文件的顺序读取，MappedByteBuffer 比传统 I/O 快 3-5 倍。

2. NIO 的优势

✅ 高性能：单线程处理数千连接（减少线程切换开销）。
✅ 非阻塞：避免线程等待，提高吞吐量。
✅ 零拷贝：FileChannel.transferTo() 直接传输文件（无需用户态缓冲）。
✅ 内存映射文件：MappedByteBuffer 加速大文件读写。

3. 适用场景

✔ 网络服务器（如 Netty、Tomcat 底层使用 NIO）。
✔ 大文件处理（内存映射文件）。
✔ 低延迟应用（金融交易、实时通信）。

❌ 不适用：简单的小文件读写（传统 I/O 更直观）。

4. NIO 的扩展：NIO2（Java 7+）

Java 7 引入了 NIO.2，新增：

• Path 和 Files：替代 File 类，简化文件操作。
• AsynchronousFileChannel：异步文件 I/O。
• WatchService：监听文件系统变更。

代码片段（NIO2 读取文件） ：

Path path = Paths.get("test.txt");
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8); // 一行搞定
Files.write(path, "新内容".getBytes(), StandardOpenOption.APPEND);

5. 小结

• NIO 核心：Buffer + Channel + Selector。
• 高并发秘诀：非阻塞 + 多路复用。
• NIO2 补充：更易用的文件 API（Path/Files）。

三、AIO

Java AIO（Asynchronous I/O，异步非阻塞 I/O）是 Java 7 引入的高性能 I/O 模型，基于事件回调和异步操作，适用于高吞吐量、低延迟的应用场景（如文件操作、网络通信）。与 NIO 不同，AIO 不需要轮询，操作系统会在 I/O 操作完成后主动通知应用。

1. AIO 核心组件

1.1 AsynchronousFileChannel（异步文件通道）

• 作用：异步读写文件，避免线程阻塞。
• 关键方法：
  • read() / write()：异步读写，通过 CompletionHandler 回调结果。
  • Future 模式：返回 Future 对象，可轮询或阻塞等待结果。

代码片段（异步文件读取） ：

Path path = Paths.get("test.txt");
AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path);

ByteBuffer buffer = ByteBuffer.allocate(1024);
fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("读取完成，字节数: " + result);
        attachment.flip();
        System.out.println(new String(attachment.array(), 0, result));
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        exc.printStackTrace();
    }
});

1.2 AsynchronousSocketChannel（异步网络通道）

• 作用：异步 TCP 通信，支持非阻塞连接、读写。
• 关键方法：
  • connect()：异步连接服务器。
  • read() / write()：异步数据传输。

代码片段（异步客户端） ：

AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
client.connect(new InetSocketAddress("127.0.0.1", 8080), null, new CompletionHandler<Void, Void>() {
    @Override
    public void completed(Void result, Void attachment) {
        ByteBuffer buffer = ByteBuffer.wrap("Hello Server".getBytes());
        client.write(buffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer result, Void attachment) {
                System.out.println("发送成功");
            }
            @Override
            public void failed(Throwable exc, Void attachment) {
                exc.printStackTrace();
            }
        });
    }
    @Override
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
    }
});

1.3 CompletionHandler（回调接口）

• 核心接口：定义异步操作完成或失败时的回调逻辑。
• 方法：
  • completed()：操作成功时触发。
  • failed()：操作失败时触发。

2. AIO 工作机制

3. 使用场景

3.1 适合 AIO 的场景

✔ 高性能文件 I/O：大文件读写（如日志分析）。
✔ 高并发网络服务：WebSocket 服务器、金融交易系统。
✔ 低延迟需求：实时通信（如游戏服务器）。

3.2 不适合 AIO 的场景

❌ 简单应用：少量连接的 HTTP 服务（BIO/NIO 更简单）。
❌ 旧系统兼容：部分操作系统对 AIO 支持不完善（如 Windows）。

4. 代码案例（AIO 服务器）

AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));

// 异步接受连接
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    @Override
    public void completed(AsynchronousSocketChannel client, Void attachment) {
        server.accept(null, this); // 继续接收新连接
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                attachment.flip();
                client.write(attachment); // 回显数据
            }
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                exc.printStackTrace();
            }
        });
    }
    @Override
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
    }
});

5. 小结

• AIO 优势：
  • 真正的异步 I/O，依赖操作系统回调（无需轮询）。
  • 减少线程上下文切换，适合高吞吐场景。
• 注意事项：
  • 代码复杂度高，建议使用框架（如 Netty）。
  • Linux 需内核支持（epoll），Windows 通过 IOCP 实现。

📌 推荐框架：直接使用 Netty（封装了 NIO/AIO 的最佳实践），避免手动处理回调地狱。

四、对比分析

1. AIO vs. NIO vs. BIO

特性	BIO	NIO	AIO
阻塞模式	阻塞	非阻塞（需轮询）	非阻塞（回调通知）
线程模型	一连接一线程	多路复用（Selector）	回调驱动（无需轮询）
复杂度	简单	中等（需管理 Buffer/Channel）	高（需理解回调逻辑）
适用场景	低并发短连接	高并发长连接	高吞吐量、低延迟（如 Proactor 模式）
操作系统支持	所有平台	所有平台	依赖操作系统（Linux 需 epoll）

2. NIO 与 BIO（线程池优化）的本质区别

NIO 和 BIO（线程池优化版）表面上看都是“用少量线程处理多连接” ，但两者的底层设计思想、性能上限和适用场景有根本性差异

2.1 BIO 线程池的伪多路复用

// BIO 线程池伪代码（表面多路复用，实际仍是阻塞式）
ExecutorService pool = Executors.newFixedThreadPool(100);
while (true) {
    Socket socket = serverSocket.accept(); // 阻塞等待连接
    pool.execute(() -> {
        InputStream in = socket.getInputStream();
        in.read(); // 线程仍阻塞在这里！
    });
}

• 本质问题：
  • 每个线程仍会阻塞在 read() 上，线程池只是限制了最大线程数。
  • 当 100 个线程全部阻塞时，第 101 个连接必须等待线程释放。

2.2 NIO 的真·多路复用

// NIO 真·多路复用（单线程管理所有连接）
Selector selector = Selector.open();
channel.register(selector, SelectionKey.OP_READ);

while (true) {
    selector.select(); // 阻塞直到任意连接有数据
    Set<SelectionKey> keys = selector.selectedKeys();
    for (SelectionKey key : keys) {
        if (key.isReadable()) {
            // 只有数据就绪的连接会被处理
            SocketChannel client = (SocketChannel) key.channel();
            client.read(buffer); // 非阻塞读取
        }
    }
}

• 核心优势：
  • 单线程即可处理数万连接（仅活跃连接消耗 CPU）。
  • 完全避免线程阻塞在 I/O 上，操作系统事件通知机制（如 epoll）负责监听就绪状态。

2.3 性能对比图

BIO 线程池模型

NIO 多路复用模型

2.4. 关键结论

1. BIO 线程池优化：
   • 只是限制了线程数量，无法解决阻塞 I/O 的本质问题。
   • 适合 低并发短连接（如 HTTP/1.0），但不适合长连接或高并发。
2. NIO 多路复用：
   • 通过操作系统事件通知（如 epoll/kqueue）实现 真正的非阻塞。
   • 适合 高并发长连接（如 WebSocket、游戏服务器）。
3. 性能差距：
   • BIO 线程池：1k 并发需要 ≈1k 线程（线程切换开销爆炸）。
   • NIO：1-2 个线程即可处理 10k+ 并发（如 Netty 默认配置）。