┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│  Async Layer  │───>  │   Task Queue  │───>  │   Sync Layer  │
│ (Non-Blocking)│<───  │ (Thread-Safe) │<───  │ (Thread Pool) │
└───────────────┘      └───────────────┘      └───────────────┘

import java.util.concurrent.*;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
public class HalfSyncHalfAsyncServer {
    // 任务队列（设置容量防止OOM）
    private final BlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>(1000);
    // 异步层：模拟NIO事件循环
    class AsyncLayer implements Runnable {
        private Selector selector;
        public AsyncLayer() throws Exception {
            this.selector = Selector.open();
            // 初始化ServerSocketChannel等（略）
        }
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 1. 非阻塞select()
                    int readyChannels = selector.selectNow();
                    if (readyChannels == 0) continue;
                    // 2. 处理IO事件（如新连接）
                    SocketChannel client = acceptNewClient(); // 伪代码
                    System.out.println("[Async] 接收新连接: " + client);
                    // 3. 生成任务并提交队列
                    taskQueue.put(() -> handleClient(client));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        private void handleClient(SocketChannel client) {
            // 实际业务处理在同步层
            System.out.println("[Sync] 处理客户端: " + client);
            // 模拟耗时操作
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
        }
    }
    // 同步层：线程池配置
    private final ExecutorService syncWorkerPool = new ThreadPoolExecutor(
        4, // 核心线程数（根据CPU核数调整）
        16, // 最大线程数（突发流量缓冲）
        30, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(100),
        new ThreadFactory() {
            private int count = 0;
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "sync-worker-" + count++);
            }
        },
        new ThreadPoolExecutor.CallerRunsPolicy() // 队列满后由提交线程执行
    );
    // 启动方法
    public void start() throws Exception {
        // 启动异步层线程
        new Thread(new AsyncLayer()).start();
        // 启动同步层消费队列
        new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Runnable task = taskQueue.take();
                    syncWorkerPool.execute(task);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
    }
    public static void main(String[] args) throws Exception {
        new HalfSyncHalfAsyncServer().start();
    }
}

// 线程池拒绝策略：当队列满时，由提交任务的线程自己执行
new ThreadPoolExecutor.CallerRunsPolicy()
// 队列选择：LinkedBlockingQueue vs ArrayBlockingQueue
// - LinkedBlockingQueue：默认无界，需设置容量
// - ArrayBlockingQueue：固定大小，更严格的控制

// 使用多个Selector（多线程异步层）
Selector[] selectors = new Selector[4];
for (int i = 0; i < selectors.length; i++) {
    selectors[i] = Selector.open();
    new Thread(new AsyncLayer(selectors[i])).start();
}

// 动态调整线程池参数
ThreadPoolExecutor pool = (ThreadPoolExecutor) syncWorkerPool;
pool.setCorePoolSize(8); // 根据系统负载动态调整
pool.setMaximumPoolSize(32);

// 队列积压监控
int queueSize = taskQueue.size(); 
// 线程池活跃度
int activeCount = pool.getActiveCount();
long completedTasks = pool.getCompletedTaskCount();