// 假設(shè)有一個(gè)單線程的Reactor，負(fù)責(zé)監(jiān)聽、接收連接、讀寫操作
class SingleThreadReactor {
    EventLoop eventLoop; // 單個(gè)事件循環(huán)線程
    
    SingleThreadReactor() {
        eventLoop = new EventLoop(); // 初始化單個(gè)事件循環(huán)
    }
    
    void start(int port) {
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(port)); // 綁定端口
        
        eventLoop.execute(() -> { // 在事件循環(huán)中執(zhí)行
            while (true) {
                SocketChannel clientSocket = serverSocket.accept(); // 接受連接
                if (clientSocket != null) {
                    handleConnection(clientSocket); // 處理連接
                }
            }
        });
        eventLoop.run(); // 啟動事件循環(huán)
    }
    
    void handleConnection(SocketChannel clientSocket) {
        // 讀寫操作，這里簡化處理
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while (clientSocket.read(buffer) > 0) {
            // 處理讀取的數(shù)據(jù)
            buffer.flip();
            // 假設(shè)處理數(shù)據(jù)邏輯...
            buffer.clear();
        }
        // 寫操作邏輯類似
    }
}

// 假設(shè)有兩個(gè)線程，一個(gè)用于監(jiān)聽連接，一個(gè)用于處理連接后的操作
class MultiThreadReactor {
    EventLoop acceptLoop;
    EventLoop workerLoop;
    
    MultiThreadReactor() {
        acceptLoop = new EventLoop(); // 接收連接的線程
        workerLoop = new EventLoop(); // 處理連接的線程
    }
    
    void start(int port) {
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(port));
        
        acceptLoop.execute(() -> { // 在接受線程中監(jiān)聽
            while (true) {
                SocketChannel clientSocket = serverSocket.accept();
                if (clientSocket != null) {
                    workerLoop.execute(() -> handleConnection(clientSocket)); // 將新連接交給工作線程處理
                }
            }
        });
        
        acceptLoop.run(); // 啟動接受線程
        workerLoop.run(); // 啟動工作線程
    }
    
    // handleConnection 方法與單線程模型中的相同
}

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class MainReactorModel {
    public static void main(String[] args) {
        // 主Reactor，用于接受連接
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // 從Reactor，用于處理連接后的讀寫操作
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                     .channel(NioServerSocketChannel.class)
                     .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             // 在這里添加業(yè)務(wù)處理器，如解碼器、編碼器、業(yè)務(wù)邏輯處理器
                             ch.pipeline().addLast(new MyBusinessHandler());
                         }
                     });

            ChannelFuture future = bootstrap.bind(8080).sync();
            System.out.println("Server started at port 8080");
            future.channel().closeFuture().sync(); // 等待服務(wù)器關(guān)閉
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}