Java 线程池

最新推荐文章于 2025-04-27 18:09:07 发布

原创最新推荐文章于 2025-04-27 18:09:07 发布

· 154 阅读

0 ·

版权

文章标签：

#Java #线程池

Java 同时被 2 个专栏收录

7 篇文章

订阅专栏

并发、多线程

1 篇文章

订阅专栏

文章目录

ThreadPoolExecutor
Executors 提供的几种默认线程池

ThreadPoolExecutor

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                3,       // 核心线程数，线程长期维持，即使在空闲状态也不会被回收
                10,  // 最大线程数，达到最大值之后，在向线程池中提交任务将会被拒绝
                0,      // 空闲线程的存活时长，超过这个时间将会被回收
                TimeUnit.MINUTES,   // 空闲线程的存活时长的时间单位
                new SynchronousQueue<>(),//任务的排队队列
                Executors.defaultThreadFactory(),      //新线程的产生方式 ，需要实现 ThreadFactory 接口
                new ThreadPoolExecutor.AbortPolicy()   //当线程池满时的拒绝策略 需要实现 RejectedExecutionHandler 接口
        );

执行规则

先判断当前线程池的大小是否小于核心线程数，如果小于，则创建线程并执行
判断任务队列是否已满，如果没有满，则提交到任务队列中
如果任务队列满了，则判断当前线程池大小是否小于最大线程池的大小，如果小于，则创建线程并执行
如果当前线程数量已经达到最大值了，则执行拒绝策略

线程回收

需要当前线程池大小大于核心线程大小
需要线程的空闲时间达到 keepAliveTime 设置的时间
如果需要回收核心线程，则需要 allowCoreThreadTimeOut 值为 true，可以通过threadPoolExecutor.allowCoreThreadTimeOut(true); 设置

任务队列

同步移交(直接提交): SynchronousQueue，new SynchronousQueue<>(); 可以看做是一个空队列，里面不会保存任何任务，
有界队列：ArrayBlockingQueue，new ArrayBlockingQueue(10); 在创建队列的时候设置队列的初始化容量，大小固定。
无界队列：LinkedBlockingQueue，new LinkedBlockingQueue(); 虽然说是无界队列，但是实际上也可以在创建的时候指定最大的大小，如果不指定，默认最大大小就是 Integer.MAX_VALUE。
优先级队列：PriorityBlockingQueue，一种特殊的无界队列这个队列将会按照任务的优先级来安排任务的执行顺序，需要插入的任务实现 Comparable 接口，或者在创建时传入Comparable接口实现类，当前优先级大就返回-1，优先级小就返回1,值越小优先级越高。

拒绝策略

AbortPolicy：抛出异常，也是默认的策略
DiscardPolicy：直接忽略
DiscardOldestPolicy ：丢弃任务队列中最老的任务，也就是最先进来还没有被执行的哪一个，然后再次提交
CallerRunsPolicy：直接由提交任务的线程执行该任务

Executors 提供的几种默认线程池

自动增长线程池

Executors.newCachedThreadPool();

创建一个线程池，线程数最大可达到Integer.MAX_VALUE。将allowCoreThreadTimeOut设置为true后，线程空闲60秒回回收。

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

定长线程池

Executors.newFixedThreadPool(2);

创建一个线程池，在创建时传入线程池大小，当任务达到最大值时将会被加到无界队列中等候

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

任务调度线程池

        // 任务调度线程池，创建的线程池是ThreadPoolExecutor的子类，传入的大小是核心线数，任务队列是无界队列
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

        // 延时执行任务，只执行一次，当传入的参数为 Callable 而不是 Runnable 可以有返回值
        ScheduledFuture scheduledFuture = scheduledExecutorService.schedule(() -> {
            System.out.println(System.currentTimeMillis());
        }, 10, TimeUnit.SECONDS);

        // 如果任务未执行，则取消执行，参数未true时，如果任务正在执行中，则调用interrupt(),尝试中断线程
        scheduledFuture.cancel(true);

        // 创建一个定时任务，首次延时 initialDelay 执行，后续每次执行间隔为 period
        // 当任务执行时间小于间隔时间时，下次任务的开始时间为 上次执行任务的开始时间 加上 间隔时间
        // 当任务执行时间大于间隔时间时，下次任务会等到上次任务执行结束之后立马执行
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {

            }
        }, 3, 5, TimeUnit.SECONDS);


        // 设置一个定时任务，每次执行任务完成之后，延时执行的时间，然后在执行下次任务
        // 也就是说，下次任务执行的的开始时间为 上次任务结束时间 加上 延时时间
        scheduledExecutorService.scheduleWithFixedDelay(() -> {

        }, 10, 5, TimeUnit.SECONDS);

如果是周期性的执行任务，当其中一次执行发生异常，后续的任务将不再执行

串行线程池

串行线程池，每次执行一个任务，执行完成之后在执行下一个任务

 ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

串行的任务调度线程池

        // 串行的任务调度线程池，一次执行一个任务
        Executors.newSingleThreadScheduledExecutor();

工作窃取线程池

这个是Java 1.8 提供的线程池，这种线程池不是扩展自 ThreadPoolExecutor ，实际上是 ForkJoinPool 类。该线程池的线程数量默认为cpu的核心数，任务并行执行，当一个任务执行完成之后就去任务队列中获取新任务继续执行，但是与上面介绍过的先进先出以及优先级队列不同，该线程池执行任务的方式是抢占式的，也就是不能保证任务的执行顺序。

ForkJoinPool forkJoinPool= (ForkJoinPool) Executors.newWorkStealingPool();