java21 虚拟动态线程池

1. 静态变量和常量

   • 定义了静态变量virtualThreadPool，用于存储线程池实例。
   • 定义了一系列静态常量，包括核心线程池大小（CORE_POOL_SIZE）、最大线程池大小（MAX_POOL_SIZE）、空闲线程存活时间（KEEP_ALIVE_TIME）、任务队列容量（QUEUE_CAPACITY）以及监控间隔（MONITOR_INTERVAL）。
     • 核心线程池大小为100。
     • 最大线程池大小为10000。
     • 空闲线程存活时间为60秒。
     • 任务队列容量为1000。
     • 监控间隔为5秒。

2. 构造方法

   • 私有化构造方法，防止外部直接实例化。
   • 创建了一个虚拟线程工厂（ThreadFactory）用于生成虚拟线程。
   • 使用ThreadPoolExecutor构造了一个虚拟动态线程池，并设置了核心线程数、最大线程数、线程空闲存活时间、任务队列容量以及拒绝策略。
   • 初始化监控器（initMonitor()）。

3. 监控器初始化方法（initMonitor）

   • 创建了一个单线程调度执行器（ScheduledExecutorService）用于执行定时任务。
   • 设置了一个定时任务，每隔MONITOR_INTERVAL秒执行一次，用于监控线程池的状态，并根据状态调整线程池的大小。

4. 动态调整线程池大小的方法（adjustPoolSize）

   • 获取线程池的活跃线程数和当前线程数。
   • 根据活跃线程数与当前线程数的比例来决定是否需要增加或减少线程池的大小。
   • 如果活跃线程数超过当前线程数的80%，且当前线程数未达到最大线程数，则增加线程池大小。
   • 如果活跃线程数低于当前线程数的50%，且当前线程数大于核心线程数，则减少线程池大小。

5. 获取单例实例的方法（getInstance）

   • 返回VirtualThreadPoolManager的唯一实例，使用了单例模式中的静态内部类方式来实现。
   • 保证了线程安全，即在多线程环境下，该类的实例仅会被创建一次。

6. 获取虚拟线程池的方法（getVirtualThreadPool）

   • 提供了获取虚拟线程池实例的方法，以便外部可以使用该线程池来执行任务。

7. 静态内部类（Holder）

   • 定义了一个静态内部类Holder，该类中包含一个静态变量INSTANCE，用于存储VirtualThreadPoolManager类的唯一实例。

8. 关闭线程池的方法（shutdown）

   • 提供了关闭线程池及其监控器的方法。
   • 在关闭之前，检查线程池和监控器是否已被实例化，如果实例化则调用shutdown()方法关闭它们。

public class VirtualThreadPoolManager {

    private static ExecutorService virtualThreadPool ;

    // 核心线程池大小
    private static final int CORE_POOL_SIZE = 100;
    // 最大线程池大小
    private static final int MAX_POOL_SIZE = 10000;
    // 空闲线程存活时间(秒)
    private static final long KEEP_ALIVE_TIME = 60L;
    // 任务队列容量
    private static final int QUEUE_CAPACITY = 1000;

    // 监控线程池状态的定时任务
    private static ScheduledExecutorService monitorExecutor;
    // 监控间隔(秒)
    private static final long MONITOR_INTERVAL = 5L;

    private VirtualThreadPoolManager() {
        // 创建虚拟线程工厂
        ThreadFactory virtualThreadFactory = Thread.ofVirtual()
                .name("dynamic-virtual-thread-", 0)
                .factory();

        //创建一个虚拟动态线程池，设置核心线程数、最大线程数、线程空闲存活时间、任务队列容量以及拒绝策略
        virtualThreadPool = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(QUEUE_CAPACITY),
                virtualThreadFactory,
                new ThreadPoolExecutor.AbortPolicy());

        // 初始化监控
        initMonitor();
    }

    private static void initMonitor() {
        monitorExecutor = Executors.newSingleThreadScheduledExecutor();
        monitorExecutor.scheduleAtFixedRate(() -> {
            ThreadPoolExecutor executor = (ThreadPoolExecutor) virtualThreadPool;

            System.out.println("线程池状态监控:");
            System.out.println("核心线程数: " + executor.getCorePoolSize());
            System.out.println("当前线程数: " + executor.getPoolSize());
            System.out.println("活跃线程数: " + executor.getActiveCount());
            System.out.println("已完成任务数: " + executor.getCompletedTaskCount());
            System.out.println("队列大小: " + executor.getQueue().size());

            // 动态调整策略
            adjustPoolSize(executor);

        }, MONITOR_INTERVAL, MONITOR_INTERVAL, TimeUnit.SECONDS);
    }

    private static void adjustPoolSize(ThreadPoolExecutor executor) {
        int activeCount = executor.getActiveCount();
        int poolSize = executor.getPoolSize();

        // 如果活跃线程数超过当前线程数的80%且未达到最大值，增加线程
        if (activeCount > poolSize * 0.8 && poolSize < MAX_POOL_SIZE) {
            int newSize = Math.min(poolSize + 100, MAX_POOL_SIZE);
            executor.setCorePoolSize(newSize);
            executor.setMaximumPoolSize(newSize);
            System.out.println("增加线程池大小到: " + newSize);
        }
        // 如果活跃线程数低于当前线程数的50%，减少线程
        else if (activeCount < poolSize * 0.5 && poolSize > CORE_POOL_SIZE) {
            int newSize = Math.max(poolSize - 100, CORE_POOL_SIZE);
            executor.setCorePoolSize(newSize);
            executor.setMaximumPoolSize(newSize);
            System.out.println("减少线程池大小到: " + newSize);
        }
    }

    // 获取单例实例
    public static synchronized VirtualThreadPoolManager getInstance() {
        return Holder.INSTANCE;
    }

    public ExecutorService getVirtualThreadPool() {
        return virtualThreadPool;
    }

    private static class Holder {
        private static final VirtualThreadPoolManager INSTANCE = new VirtualThreadPoolManager();
    }

    // 关闭线程池
    public static void shutdown() {
        if (virtualThreadPool != null) {
            virtualThreadPool.shutdown();
        }
        if (monitorExecutor != null) {
            monitorExecutor.shutdown();
        }
    }
}