从单线程到主从多线程：手把手教你用Java NIO模拟实现三种Reactor模型（附完整代码）

在当今高并发的网络应用开发中，理解底层I/O模型的工作原理至关重要。Reactor模式作为一种经典的事件驱动设计范式，能够高效处理大量并发连接，被广泛应用于各类高性能服务器框架中。本文将带你从零开始，仅使用Java标准库的NIO API，逐步实现单Reactor单线程、单Reactor多线程和主从Reactor多线程这三种模型，让你真正掌握网络编程的核心机制。

1. 环境准备与基础概念

在开始编码之前，我们需要确保开发环境就绪并理解关键概念。Java NIO（New I/O）提供了非阻塞I/O操作的支持，这是实现Reactor模式的基础。

必备工具与环境：

• JDK 8或更高版本
• 任意Java IDE（IntelliJ IDEA、Eclipse等）
• Maven或Gradle构建工具（可选）

核心NIO组件：

• Selector：多路复用器，用于监听多个通道的事件
• ServerSocketChannel：服务器套接字通道，监听新连接
• SocketChannel：客户端套接字通道，处理数据传输
• ByteBuffer：数据缓冲区，用于读写操作

提示：在开始前，建议先熟悉Java NIO的基本API，特别是Selector的使用方法。

2. 单Reactor单线程模型实现

这是最简单的Reactor模型实现，所有操作都在单个线程中完成。我们先来看核心代码结构：

java复制public class SingleThreadReactor implements Runnable {
    final Selector selector;
    final ServerSocketChannel serverSocket;
    
    // 初始化Reactor
    SingleThreadReactor(int port) throws IOException {
        selector = Selector.open();
        serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        sk.attach(new Acceptor());
    }
    
    public void run() {
        try {
            while (!Thread.interrupted()) {
                selector.select();
                Set<SelectionKey> selected = selector.selectedKeys();
                Iterator<SelectionKey> it = selected.iterator();
                while (it.hasNext()) {
                    dispatch(it.next());
                }
                selected.clear();
            }
        } catch (IOException ex) { /* 处理异常 */ }
    }
    
    void dispatch(SelectionKey k) {
        Runnable r = (Runnable)(k.attachment());
        if (r != null) {
            r.run();
        }
    }
    
    class Acceptor implements Runnable {
        public void run() {
            try {
                SocketChannel c = serverSocket.accept();
                if (c != null) {
                    new Handler(selector, c);
                }
            } catch (IOException ex) { /* 处理异常 */ }
        }
    }
}

模型工作流程：

1. Reactor线程通过Selector监听所有事件
2. 当有新连接到达时，Acceptor处理连接并创建Handler
3. Handler负责处理该连接的所有I/O操作
4. 所有操作都在同一个线程中串行执行

性能特点分析：

注意：这种模型虽然简单，但在处理耗时业务时会严重影响整体性能，不适合生产环境的高并发场景。

3. 单Reactor多线程模型实现

为了解决单线程模型的性能瓶颈，我们引入线程池来处理业务逻辑，形成单Reactor多线程模型。

关键改进点：

• 保持Reactor单线程处理I/O事件
• 引入线程池处理业务逻辑
• Handler只负责I/O操作，业务逻辑交给Worker线程

java复制public class MultiThreadHandler implements Runnable {
    final SocketChannel socket;
    final SelectionKey sk;
    static final int READING = 0, SENDING = 1;
    int state = READING;
    
    // 使用线程池处理业务
    static ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    
    MultiThreadHandler(Selector sel, SocketChannel c) throws IOException {
        socket = c;
        c.configureBlocking(false);
        sk = socket.register(sel, 0);
        sk.attach(this);
        sk.interestOps(SelectionKey.OP_READ);
        sel.wakeup();
    }
    
    public void run() {
        try {
            if (state == READING) read();
            else if (state == SENDING) send();
        } catch (IOException ex) { /* 处理异常 */ }
    }
    
    void read() throws IOException {
        ByteBuffer input = ByteBuffer.allocate(1024);
        socket.read(input);
        // 将业务处理交给线程池
        pool.execute(new Processer(input));
        state = SENDING;
        sk.interestOps(SelectionKey.OP_WRITE);
    }
    
    void send() throws IOException {
        // 发送处理结果
        state = READING;
        sk.interestOps(SelectionKey.OP_READ);
    }
    
    class Processer implements Runnable {
        final ByteBuffer input;
        
        Processer(ByteBuffer input) {
            this.input = input;
        }
        
        public void run() {
            // 模拟业务处理
            try {
                Thread.sleep(100); // 模拟耗时操作
            } catch (InterruptedException ex) { /* 处理异常 */ }
        }
    }
}

三种模型线程分工对比：

提示：这种模型适合业务处理较耗时的场景，但Reactor单线程仍然是性能瓶颈。

4. 主从Reactor多线程模型实现

这是最复杂的模型，也是性能最好的实现方式。我们将Reactor分为主从两部分，主Reactor负责接收连接，从Reactor负责处理I/O事件。

架构设计要点：

• MainReactor：专门处理连接事件
• SubReactor：处理已建立连接的I/O事件
• 线程池：处理业务逻辑

java复制public class MasterSlaveReactor {
    public static void main(String[] args) throws IOException {
        new MasterSlaveReactor(8080).run();
    }
    
    final ServerSocketChannel serverSocket;
    final AtomicInteger next = new AtomicInteger(0);
    final Selector[] selectors = new Selector[2]; // 主从选择器
    final SubReactor[] subReactors; // 从Reactor
    
    MasterSlaveReactor(int port) throws IOException {
        // 初始化主选择器
        selectors[0] = Selector.open();
        // 初始化从选择器
        selectors[1] = Selector.open();
        serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        // 主Reactor注册连接事件
        SelectionKey sk = serverSocket.register(selectors[0], SelectionKey.OP_ACCEPT);
        sk.attach(new Acceptor());
        // 初始化从Reactor
        subReactors = new SubReactor[Runtime.getRuntime().availableProcessors()];
        for (int i = 0; i < subReactors.length; i++) {
            subReactors[i] = new SubReactor(selectors[1]);
        }
    }
    
    public void run() {
        // 启动主Reactor
        new Thread(new Reactor(selectors[0])).start();
        // 启动从Reactor
        for (SubReactor subReactor : subReactors) {
            new Thread(subReactor).start();
        }
    }
    
    class Reactor implements Runnable {
        final Selector selector;
        
        Reactor(Selector selector) {
            this.selector = selector;
        }
        
        public void run() {
            try {
                while (!Thread.interrupted()) {
                    selector.select();
                    Set<SelectionKey> selected = selector.selectedKeys();
                    Iterator<SelectionKey> it = selected.iterator();
                    while (it.hasNext()) {
                        dispatch(it.next());
                    }
                    selected.clear();
                }
            } catch (IOException ex) { /* 处理异常 */ }
        }
    }
    
    class SubReactor implements Runnable {
        final Selector selector;
        
        SubReactor(Selector selector) {
            this.selector = selector;
        }
        
        public void run() {
            try {
                while (!Thread.interrupted()) {
                    selector.select();
                    Set<SelectionKey> selected = selector.selectedKeys();
                    Iterator<SelectionKey> it = selected.iterator();
                    while (it.hasNext()) {
                        dispatch(it.next());
                    }
                    selected.clear();
                }
            } catch (IOException ex) { /* 处理异常 */ }
        }
    }
    
    class Acceptor implements Runnable {
        public void run() {
            try {
                SocketChannel c = serverSocket.accept();
                if (c != null) {
                    // 轮询选择一个从Reactor处理新连接
                    new MultiThreadHandler(
                        selectors[1].selector(), 
                        c
                    );
                }
            } catch (IOException ex) { /* 处理异常 */ }
        }
    }
}

性能优化技巧：

• 根据CPU核心数动态调整SubReactor数量
• 使用无锁数据结构减少线程竞争
• 合理设置Selector的超时时间避免空转
• 使用直接缓冲区减少内存拷贝

5. 模型对比与实战建议

经过上述三种模型的实现，我们来总结它们的特性和适用场景。

三种Reactor模型对比表：

在实际项目中，选择哪种模型需要考虑以下因素：

1. 预期并发量：低并发可选择单线程，高并发必须使用主从模型
2. 业务处理耗时：耗时业务需要多线程处理
3. 硬件资源：多核CPU适合主从模型
4. 开发维护成本：简单项目不必过度设计

性能测试数据参考：

提示：这些测试数据是在4核CPU、8GB内存的测试环境下获得的，实际性能会因硬件配置和业务逻辑而异。

在实现过程中，有几个常见的坑需要注意：

• Selector的wakeup调用要适度，过度使用会影响性能
• 注意处理半关闭的连接状态
• 缓冲区大小需要根据实际数据量调整
• 合理设置线程池参数避免资源耗尽