java线程池

最新推荐文章于 2024-04-03 12:53:53 发布

chengbinbbs

最新推荐文章于 2024-04-03 12:53:53 发布

阅读量285

点赞数

分类专栏： Java 文章标签： java 多线程线程池 newCachedThreadPool newFixedThreadPool

本文链接：https://blog.csdn.net/chengbinbbs/article/details/86707844

版权

Java 专栏收录该内容

36 篇文章 1 订阅

订阅专栏

一、什么是线程池？

线程池是用于创建和管理线程的容器，可以提高系统的资源利用率。建立线程池的目的之一就是因为线程的重建和销毁会消耗时间和空间，线程池可以实现线程的重复利用，节约线程的销毁和重建成本。线程池（Thread Pool）对于限制应用程序中同一时刻运行的线程数很有用。因为每启动一个新线程都会有相应的性能开销，每个线程都需要给栈分配一些内存等等。JDK1.5之后java.util.concurrent包下新增了一个工厂类Executors用于线程池的创建。

二、线程池创建

java在在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1. newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

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

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

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

3. newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

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

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

总结：除了newScheduledThreadPool的内部实现特殊一点之外，其它线程池内部都是基于ThreadPoolExecutor类（Executor的子类）实现的。这四种线程池都存在可能导OOM问题，single和fixed虽然限制了线程个数，但是允许线程等待的队列最大个数却是Integer.MAX_VALUE，可能会堆积大量的请求，导致OOM。catched和secheduled方式，最大线程个数就是Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

阿里巴巴Java开发手册中也明确指出，而且用的词是『不允许』使用Executors创建线程池。正确姿势是：

private static ExecutorService executor = new ThreadPoolExecutor(10, 10,
        60L, TimeUnit.SECONDS,
        new ArrayBlockingQueue(10));

三、实现原理

ThreadPoolExecutor内部具体实现：

ThreadPoolExecutor类构造器语法形式：

ThreadPoolExecutor（corePoolSize,maxPoolSize,keepAliveTime,timeUnit,workQueue,threadFactory,handle);

ThreadPoolExecutor参数：

corePoolSize: 池中所保存的线程数，包括空闲线程
maximumPoolSize: 池中允许的最大线程数
keepAliveTime: 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间
unit: keepAliveTime参数的时间单位
workQueue: 执行前用于保持任务的队列。此队列仅保持由execute方法提交的Runnable任务
threadFactory: 执行程序创建新线程时使用的工厂
handler: 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理任务

newFixedThreadPool： corePoolSize和maximumPoolSize的大小是一样的（实际上，如果使用无界queue的话，maximumPoolSize参数是没有意义的）。

所有BlockingQueue都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：

如果运行的线程小于corePoolSize，则Executor始终首选添加新的线程，而不进行排队。（如果当前运行的线程小于corePoolSize，则任务根本不会存放，添加到queue中，而是直接开始运行）
如果运行的线程等于或多余corePoolSize，则Executor始终首选将请求加入队列，而不添加新的线程。
如果无法将请求加入队列，则创建新的线程，除非创建此线程超出maximumPoolSize，在这种情况下，任务将被拒绝。

排队有三种通用策略：

直接提交：工作队列的默认选项是SynchronousQueue，它将任务直接提交给线程而不保持它们。如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界maximumPoolSizes以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
无界队列：使用无界队列（例如，不具有预定义容量的LinkedBlockingQueue）将导致在所有corePoolSize线程都忙时新任务在队列中等待。这样，创建的线程就不会超过corePoolSize。（因此，maximumPoolSize的值也就无效了）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列。例如，在web服务器中，这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
有界队列：当使用有线的maximumPoolSize时，有界队列（如ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折中：使用大型队列和小型池可以最大限度地降低CPU使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是I/O边界），则系统可能为超过你许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。
keepAliveTime: 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

RejectedExecutionHandler:
RejectedExecutionHandler接口提供了对于拒绝任务的处理的自定方法的机会。在ThreadPoolExecutor中已经默认包含了4种策略。

CallerRunsPolicy: 线程调用运行该任务的execute本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        r.run();
    }
}

此策略不想放弃执行任务，但是由于池中已经没有任务资源了，那么就直接调用该execute的线程本身来执行。

AbortPolicy: 处理程序遭到拒绝将抛出运行时RejectedExecutionException

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    throw new RejectedExecutionException("Task " + r.toString() +
                                         " rejected from " +
                                         e.toString());
}

这种策略直接抛出异常，丢弃任务。

DiscardPolicy: 不能执行的任务将删除

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}

这种策略和AbortPolicy几乎一样，也是丢弃任务，只不过它不抛出异常。

DiscardOldestPolicy: 如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        e.getQueue().poll();
        e.execute(r);
    }
}

该策略稍微复杂一些，在pool没有关闭的前提下首先丢掉缓存在队列中的最早的任务，然后重新重试运行该任务。这个策略需要适当小心。设想：如果其他线程都还在运行，那么新来任务踢掉旧任务，缓存在queue中，再来一个任务又会踢掉queue中最老的任务。

keepAliveTime和maximumPoolSize及BlockingQueue的类型均由关系。如果BlockingQueue是无界的，那么永远不会触发maximumPoolSize，自然keepAliveTime也就没有了意义。反之，如果核心数较小，有界BlockingQueue数值又较小，同时keepAliveTime又设的很小，如果任务频繁，那么系统就会频繁的申请回收线程。

四、SpringBoot 使用线程池

SpringBoot创建线程池，创建TaskPoolConfig用来管理线程池的创建，其中@EnableAsync注解表示是启用异步线程。推荐如下写法：

@EnableAsync
@Configuration
public class TaskPoolConfig {


    /**
     * 创建异步线程池
     * @return
     */
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);   //线程池创建时候初始化的线程数
        executor.setMaxPoolSize(20);    //线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setQueueCapacity(200); //用来缓冲执行任务的队列
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("taskExecutor-");
        //用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
        executor.setAwaitTerminationSeconds(60);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    /**
     * 消费队列线程
     * @return
     */
    @Bean("sendCouponPool")
    public Executor sendCouponThreadPool(){
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("sendCouponThreadPool-%d").build();

        return new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(100),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy());
    }
}

使用方法：

    @Resource(name = "sendCouponPool")
    private ExecutorService sendCouponPool;

    @Override
    public void execute() {
        //消费队列
        for (int i = 0; i < 5; i++) {
            sendCouponPool.execute(new ConsumerQueueThread());
        }
    }
    //异步线程
    @Async("taskExecutor")
    public void findUsers(){
        try {
            System.out.println("异步执行查询任务开始...");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("异步执行查询任务结束...");
    }

当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行；如果阻塞队列满了，那就创建新的线程执行当前任务；直到线程池中的线程数达到maxPoolSize,这时再有任务来，只能执行reject()处理该任务。

https://blog.wangqi.love/articles/Java/线程池整理.html