创建线程池

创建一般线程池

推荐的方法：new ThreadPoolExecutor ,

不推荐使用FixThreadPool 和 SingleThreadPool,因为这两个类的请求队列长度是最大整数，任务堆积过多会导致内存不够用从而OOM.

 

 创建线程的工具类--单例

public enum FixedThreadPoolUtil {

    /**
     * 单例-固定线程池工具
     */
    INSTANCE;

    private ExecutorService pool;

    FixedThreadPoolUtil() {
        LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(5_000);
        pool = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, queue, new ThriftThreadFactory());
    }

    static class ThriftThreadFactory implements ThreadFactory {
        private static final AtomicInteger POOL_NUMBER = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        ThriftThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            namePrefix = "customized-thread-pool-" + POOL_NUMBER.getAndIncrement() + "-thread-";
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon()) {
                t.setDaemon(false);
            }
            if (t.getPriority() != Thread.NORM_PRIORITY) {
                t.setPriority(Thread.NORM_PRIORITY);
            }
            return t;
        }
    }

    /**
     * 执行任务
     *
     * @param task 任务
     */
    public void execute(Runnable task) {
        pool.execute(task);
    }
}

 

 如果不需要对写log规范化，简单写法

public enum ThreadPoolExecutorUtil {

    INSTANCE;
    private final ThreadPoolExecutor threadPoolExecutor;

    ThreadPoolExecutorUtil() {
        threadPoolExecutor = new ThreadPoolExecutor(5, 5, 10, TimeUnit.MINUTES, new LinkedBlockingDeque<>());
    }

    public void execute(Runnable runnable) {
        threadPoolExecutor.execute(runnable);
    }

}

 

 

ThreadGroup--线程组:

可以批量管理线程或线程组对象，有效地对线程或线程组对象进行组织。用户创建的所有线程都属于指定线程组，如果没有显示指定属于哪个线
程组，那么该线程就属于默认线程组（即main线程组）。
获取线程组的方法：

SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();

SecurityManager --安全管理器

安全管理器是一个允许应用程序实现安全策略的类。它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。

线程池execute和submit区别：

execute：没有返回值
submit:有返回值

 

 

创建延时线程池

延时执行一次

循环延时执行

/**
 * 延时 / 定时任务线程池
 *
 * @author:heyaolei
 * @create: 2023-02-17
 */
public enum ScheduledExecutorServiceUtil {

    INSTANCE;

    private ScheduledExecutorService scheduledExecutorService;

    ScheduledExecutorServiceUtil() {
        scheduledExecutorService = Executors.newScheduledThreadPool(5);
    }

    /**
     * 单一定时任务
     *
     * @param runnable
     * @param delay
     * @param timeUnit
     */
    public void singleSchedule(Runnable runnable, long delay, TimeUnit timeUnit) {
        scheduledExecutorService.schedule(runnable, delay, timeUnit);
    }

    /**
     * 周期性调用(每个任务间隔多久执行，比如间隔一分钟)
     *
     * @param runnable
     * @param delay
     * @param period
     * @param timeUnit
     */
    public void scheduleAtFixedRate(Runnable runnable, long delay, long period, TimeUnit timeUnit) {
        scheduledExecutorService.scheduleAtFixedRate(runnable, delay, period, timeUnit);
    }

    /**
     * 任务执行完成，关闭线程池
     */
    public void shutdown() {
        if (!scheduledExecutorService.isTerminated()) {
            scheduledExecutorService.shutdown();
        }
    }

    /**
     * 周期性调用（一个任务执行完成后，间隔多久再执行另一个任务）
     *
     * @param runnable
     * @param initialDelay
     * @param delay
     * @param timeUnit
     */
    public void scheduleWithFixedDelay(Runnable runnable, long initialDelay, long delay, TimeUnit timeUnit) {
        scheduledExecutorService.scheduleWithFixedDelay(runnable, initialDelay, delay, timeUnit);
    }
    
}