java单例线程池，管理线程池的创建和使用

博客描述：实现线程池的单例模式

在这份Java代码中，通过ThreadPoolSingleton枚举类实现了线程池的单例模式。通过使用单例模式，可以确保整个应用程序只有一个线程池实例，方便统一管理和控制线程池的行为。

 

import cn.hutool.core.thread.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.*;
 
 
public enum ThreadPoolSingleton {
 
    /**
     * 线程池实例
     */
    INSTANCE;
 
    private final ThreadPoolExecutor executor;
 
    private final Logger logger = LoggerFactory.getLogger(ThreadPoolSingleton.class);
 
    public ThreadPoolExecutor getInstance() {
        return executor;
    }
 
    ThreadPoolSingleton() {
        //记录异常
        ThreadFactory namedThreadFactory = ThreadFactoryBuilder.create()
                .setNamePrefix("admin-thread-")
                .setUncaughtExceptionHandler((thread, throwable) -> logger.error("ThreadPool {} got exception", thread, throwable))
                .build();
        //核心线程数大小
        final int corePoolSize = 4;
        //最大线程数大小,阻塞队列占满后会在线程池中继续开启新的线程,总的线程数量不会大于最大线程数
        final int maximumPoolSize = 4;
        //最大线程数空闲后的存活时间
        final long keepAliveTime = 1L;
        //最大线程数空闲后的存活时间的单位
        final TimeUnit timeUnit = TimeUnit.MINUTES;
        //阻塞队列,核心线程数占满后会把新入线程放入阻塞队列
        final ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(10);
        //拒绝策略,最大线程数占满之后会执行此策略
        //由调用线程（提交任务的线程）处理该任务
        final ThreadPoolExecutor.CallerRunsPolicy callerRunsPolicy = new ThreadPoolExecutor.CallerRunsPolicy();
        //丢弃任务并抛出RejectedExecutionException异常
        //final ThreadPoolExecutor.CallerRunsPolicy CALLER_RUNS_POLICY = new ThreadPoolExecutor.AbortPolicy();
        //丢弃任务，不抛异常
        //final ThreadPoolExecutor.CallerRunsPolicy CALLER_RUNS_POLICY = new ThreadPoolExecutor.DiscardPolicy();
        //丢弃队列中最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务
        //final ThreadPoolExecutor.CallerRunsPolicy CALLER_RUNS_POLICY = new ThreadPoolExecutor.DiscardOldestPolicy();
        executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, timeUnit, workQueue, namedThreadFactory, callerRunsPolicy);
    }
 
    /**
     * 需要获取返回值调用此方法
     *
     * @Param callable
     * @param <T>
     * @return
     */
    public static <T> Future<T> submit(Callable<T> callable) {
        return INSTANCE.getInstance().submit(callable);
    }
 
    /**
     * 不需要获取返回值调用此方法
     *
     * @param runnable
     */
    public static void execute(Runnable runnable) {
        INSTANCE.getInstance().execute(runnable);
    }
}

关键功能及实现：

1. 单例模式实现：

   • 使用枚举类的方式实现单例模式，通过INSTANCE确保只有一个线程池实例存在。

2. 线程池配置：

   • 在构造方法中初始化了一个ThreadPoolExecutor实例，设置了核心线程数、最大线程数、阻塞队列大小、线程存活时间等参数。
   • 设置了线程工厂，用于创建新线程，并设置了未捕获异常处理器，用于记录线程池中发生的异常信息。

3. 提交任务方法：

   • 提供了submit(Callable<T> callable)方法用于提交带返回值的任务到线程池中，并返回Future对象。
   • 提供了execute(Runnable runnable)方法用于提交不需要返回值的任务到线程池中。

使用方法：

1. 通过ThreadPoolSingleton.getInstance()获取线程池实例。
2. 调用submit(Callable<T> callable)方法提交带返回值的任务，或调用execute(Runnable runnable)方法提交不需要返回值的任务。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
     
public class Main {
    public static void main(String[] args) {
        // 创建一个 Callable 任务
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // 执行耗时操作，并返回结果
                return longRunningTask();
            }
        };
         
        // 提交任务并获取 Future 对象
        Future<Integer> future = ThreadPoolSingleton.submit(callable);
         
        try {
            // 阻塞等待任务执行完成并获取结果
            int result = future.get();
            System.out.println("任务执行结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
     
    private static int longRunningTask() {
        // 执行耗时操作，这里假设返回一个数值
        return 42;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个实现了 Runnable 接口的任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 执行耗时操作
                longRunningTask();
            }
        };
         
        // 提交任务
        ThreadPoolSingleton.execute(runnable);
    }
     
    private static void longRunningTask() {
        // 执行耗时操作
        System.out.println("任务执行中...");
    }
}