【Java从入门到入土】34：NIO：高并发I/O的基石

在Java IO编程中，BIO（阻塞IO）曾是基础实现，但面对高并发场景时，“一个连接一个线程”的模型暴露出严重的性能瓶颈。而NIO（Non-blocking IO，非阻塞IO）作为JDK 1.4引入的新IO模型，通过Buffer（缓冲区）、Channel（通道）、Selector（选择器） 三大核心组件，实现了“单线程处理多连接”的非阻塞I/O，成为Netty、Tomcat等高性能框架的底层基石。今天从BIO的痛点切入，拆解NIO的核心组件、非阻塞原理及实战用法，让你理解高并发I/O的实现逻辑。

🚫 BIO的致命短板：一个连接一个线程

BIO（Blocking IO）即传统阻塞式I/O，是Java早期处理I/O的核心方式，其核心逻辑是：

• 服务器端为每个客户端连接创建一个独立线程处理；
• 线程在等待数据（如Socket读取）、写入数据时会全程阻塞，直到操作完成。

1. BIO模型示意图

2. BIO的核心问题

• 资源浪费：高并发下创建大量线程，线程切换、上下文开销巨大；
• 阻塞瓶颈：线程在accept()、read()、write()时均会阻塞，即使无数据处理，线程也无法复用；
• 性能上限低：单机能支撑的连接数受限于线程数（通常几百到几千），无法应对万级以上并发。

3. BIO示例（对比理解NIO优势）

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

// BIO服务器：一个连接一个线程
public class BioServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO服务器启动，监听8080端口...");

        while (true) {
            // 阻塞：等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("新客户端连接：" + socket.getInetAddress());

            // 为每个连接创建新线程
            new Thread(() -> {
                try (InputStream is = socket.getInputStream()) {
                    byte[] buffer = new byte[1024];
                    while (true) {
                        // 阻塞：等待数据读取
                        int len = is.read(buffer);
                        if (len == -1) break;
                        System.out.println("收到数据：" + new String(buffer, 0, len));
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

🧩 NIO核心三组件：Buffer、Channel、Selector

NIO的核心设计是“面向缓冲区+非阻塞+多路复用”，通过三大组件协同，突破BIO的性能瓶颈：

1. Buffer：数据的“容器”

Buffer是NIO中存储数据的核心载体，所有NIO的读写操作都必须通过Buffer完成（区别于BIO的流直接读写）。

（1）核心属性（position、limit、capacity）

Buffer的读写状态由三个核心属性控制，以字节缓冲区ByteBuffer为例：

（2）核心操作（切换读写模式）

• flip()：写模式→读模式，重置position=0，limit=原position；
• rewind()：读模式下重置position=0，可重复读取数据；
• clear()：清空缓冲区（并非删除数据），重置position=0、limit=capacity，进入写模式；
• compact()：将未读取的数据移到缓冲区开头，重置position为未读数据末尾，进入写模式。

（3）ByteBuffer用法示例

import java.nio.ByteBuffer;

public class BufferTest {
    public static void main(String[] args) {
        // 1. 创建缓冲区：容量8字节
        ByteBuffer buffer = ByteBuffer.allocate(8);
        System.out.println("初始状态：position=" + buffer.position() 
                + "，limit=" + buffer.limit() + "，capacity=" + buffer.capacity());
        // 输出：position=0，limit=8，capacity=8（写模式）

        // 2. 写数据（position自增）
        buffer.put((byte) 'A').put((byte) 'B').put((byte) 'C');
        System.out.println("写入后：position=" + buffer.position() 
                + "，limit=" + buffer.limit() + "，capacity=" + buffer.capacity());
        // 输出：position=3，limit=8，capacity=8

        // 3. 切换为读模式（flip()）
        buffer.flip();
        System.out.println("flip后（读模式）：position=" + buffer.position() 
                + "，limit=" + buffer.limit() + "，capacity=" + buffer.capacity());
        // 输出：position=0，limit=3，capacity=8

        // 4. 读数据（position自增）
        while (buffer.hasRemaining()) { // 判断是否有未读数据
            System.out.print((char) buffer.get() + " ");
        }
        // 输出：A B C
        System.out.println("\n读取后：position=" + buffer.position() 
                + "，limit=" + buffer.limit() + "，capacity=" + buffer.capacity());
        // 输出：position=3，limit=3，capacity=8

        // 5. 清空缓冲区，重新写
        buffer.clear();
        System.out.println("clear后：position=" + buffer.position() 
                + "，limit=" + buffer.limit() + "，capacity=" + buffer.capacity());
        // 输出：position=0，limit=8，capacity=8
    }
}

（4）Buffer类型

JDK提供了多种类型的Buffer，适配不同数据类型（除boolean外）：

• 基础类型：ByteBuffer（最常用）、CharBuffer、IntBuffer、LongBuffer等；
• 直接缓冲区：ByteBuffer.allocateDirect(1024)，直接分配物理内存（非JVM堆），减少拷贝，性能更高（但创建/销毁开销大）。

2. Channel：双向的数据通道

Channel（通道）是NIO中连接数据源（文件、网络套接字）和Buffer的桥梁，核心特性：

• 双向性：既可以读也可以写（BIO的流是单向的：输入流/输出流）；
• 非阻塞：支持非阻塞读写（需配合Selector）；
• 可复用：一个Channel可被多个操作复用，无需绑定线程。

（1）常用Channel实现类

（2）SocketChannel示例（非阻塞客户端）

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

// NIO非阻塞客户端
public class NioClient {
    public static void main(String[] args) throws IOException {
        // 1. 打开通道并设置非阻塞
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 2. 连接服务器（非阻塞，立即返回）
        socketChannel.connect(new InetSocketAddress("localhost", 8080));

        // 3. 等待连接完成
        while (!socketChannel.finishConnect()) {
            System.out.println("等待连接中，可处理其他任务...");
            Thread.sleep(100); // 模拟处理其他任务
        }

        // 4. 写数据到服务器
        String msg = "Hello NIO Server!";
        ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
        socketChannel.write(buffer);
        System.out.println("数据发送完成");

        // 5. 关闭通道
        socketChannel.close();
    }
}

3. Selector：单线程处理多连接的核心

Selector（选择器）是NIO实现“多路复用”的关键，核心作用：

• 单线程监听多个Channel的状态（如：是否可读、可写、有新连接）；
• 仅当Channel有就绪事件时，才进行读写操作，避免线程阻塞；
• 实现“单线程管理多Channel”，突破BIO的线程限制。

（1）Selector核心事件

（2）Selector工作流程

（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;

// NIO Selector服务器：单线程处理多连接
public class NioSelectorServer {
    public static void main(String[] args) throws IOException {
        // 1. 打开服务器通道并设置非阻塞
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(8080));
        System.out.println("NIO服务器启动，监听8080端口...");

        // 2. 创建Selector并注册服务器通道（监听ACCEPT事件）
        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 3. 循环监听就绪事件
        while (true) {
            // 阻塞：等待至少一个通道就绪（返回就绪的通道数）
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;

            // 4. 获取就绪的SelectionKey集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            // 5. 处理就绪事件
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove(); // 必须移除，避免重复处理

                // 处理新连接（ACCEPT事件）
                if (key.isAcceptable()) {
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = serverChannel.accept(); // 非阻塞
                    socketChannel.configureBlocking(false);
                    // 注册客户端通道到Selector，监听READ事件
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                    System.out.println("新客户端连接：" + socketChannel.getRemoteAddress());
                }

                // 处理数据读取（READ事件）
                if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = (ByteBuffer) key.attachment(); // 获取绑定的缓冲区
                    int len = socketChannel.read(buffer);
                    if (len == -1) {
                        // 连接断开
                        socketChannel.close();
                        key.cancel();
                        System.out.println("客户端断开连接");
                        continue;
                    }
                    // 读取数据
                    buffer.flip();
                    String msg = new String(buffer.array(), 0, buffer.limit());
                    System.out.println("收到客户端数据：" + msg);
                    buffer.clear();
                }
            }
        }
    }
}

🚀 非阻塞IO的实现原理

NIO的非阻塞核心依赖操作系统的多路复用机制（如Linux的epoll、Windows的IOCP），区别于BIO的“内核阻塞等待数据”，NIO的非阻塞流程如下：

1. 非阻塞读操作流程

2. 多路复用的底层逻辑

Selector的本质是操作系统提供的select/poll/epoll系统调用：

• 应用层将所有需要监听的Channel（文件描述符）注册到Selector；
• 内核监听这些文件描述符的就绪状态，仅当有事件发生时，才通知应用层；
• 应用层仅处理就绪的Channel，避免了对未就绪Channel的无效阻塞。

3. NIO vs BIO核心差异

📂 文件NIO：Files工具类的便捷方法

JDK 7引入的java.nio.file包（NIO.2）大幅简化了文件操作，Files工具类提供了一系列静态方法，替代传统的File类，支持文件的创建、读取、复制、删除等操作，且兼容NIO的非阻塞特性。

1. Files核心方法

2. Files用法示例

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class FilesTest {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("test.txt");

        // 1. 写入文件
        String content = "Hello NIO.2 Files!\nJava NIO 从入门到精通";
        Files.write(path, content.getBytes());
        System.out.println("文件写入完成");

        // 2. 读取文件所有行
        List<String> lines = Files.readAllLines(path);
        System.out.println("文件内容：");
        lines.forEach(System.out::println);

        // 3. 复制文件
        Path copyPath = Paths.get("test_copy.txt");
        Files.copy(path, copyPath);
        System.out.println("文件复制完成");

        // 4. 删除文件
        Files.delete(copyPath);
        System.out.println("复制文件已删除");

        // 5. 遍历目录
        Path dir = Paths.get(".");
        System.out.println("当前目录文件：");
        Files.walk(dir, 1) // 遍历深度1（仅当前目录）
             .filter(Files::isRegularFile) // 仅普通文件
             .forEach(System.out::println);
    }
}

3. FileChannel：文件的NIO通道

FileChannel是文件的NIO通道实现，支持非阻塞读写（需配合RandomAccessFile）、文件锁定、内存映射等高级特性，性能优于传统文件流：

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

public class FileChannelTest {
    public static void main(String[] args) throws Exception {
        // 打开文件通道（读写模式）
        RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
        FileChannel channel = raf.getChannel();

        // 1. 读取文件到缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int len = channel.read(buffer);
        buffer.flip();
        System.out.println("FileChannel读取：" + new String(buffer.array(), 0, len));

        // 2. 写入文件（追加到末尾）
        channel.position(channel.size()); // 移动指针到文件末尾
        String appendContent = "\n追加的内容（FileChannel）";
        buffer.clear();
        buffer.put(appendContent.getBytes());
        buffer.flip();
        channel.write(buffer);

        // 3. 关闭通道
        channel.close();
        raf.close();
    }
}

📌 核心总结

NIO作为高并发I/O的基石，核心是“非阻塞+多路复用”，关键要点如下：

1. BIO痛点：一个连接一个线程，阻塞导致资源浪费，高并发性能差；
2. NIO三组件：Buffer（数据容器，核心属性position/limit/capacity）、Channel（双向通道）、Selector（多路复用器，单线程处理多连接）；
3. 非阻塞原理：依赖操作系统多路复用机制，仅当Channel就绪时才处理，避免无效阻塞；
4. 文件NIO：Files工具类简化文件操作，FileChannel支持高级文件I/O特性；
5. 应用场景：NIO是Netty、Tomcat等高性能框架的底层，适用于万级以上并发的网络通信场景。

掌握NIO的核心逻辑，就能理解高并发I/O的设计思路，无论是手写NIO服务器，还是学习Netty等框架，都能抓住底层本质——这也是从“入门”到“精通”Java并发编程的关键一步。