ThreadPoolExecutor

最新推荐文章于 2023-08-28 14:26:48 发布

正说杂谈

最新推荐文章于 2023-08-28 14:26:48 发布

阅读量255

点赞数

分类专栏： Java 文章标签： JUC

本文链接：https://blog.csdn.net/linuxerlin/article/details/101540730

版权

Java 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

作用：

大量异步任务的场景下，可以提升性能，避免了每个任务都要分配一个线程带来的资源消耗。
提供管理资源的能力，包括统计当前的线程使用情况，任务的各种状态统计(已完成的任务数量、已提交的任务数量、排队的任务数量等)

参数：

corePoolSize:池中固定的线程数量，当然也和创建时的策略有关，取决于是prestartCoreThread还是prestartAllCoreThreads，是一次全部启动还是按需逐步启动，从0慢慢增加到corePoolSize的大小。默认是后者。1）场景1:但线程数没到达corePoolSize的时候，此时提交任务，是会直接分配线程来执行该任务的。2）场景2：加入超过corePoolSize但小于maximumPoolSize的线程正在运行，只有在队列满的情况下才会创建线程。
maximumPoolSize:池中允许的最大线程数。
keepAliveTime:如果有超过corePoolSize数量的线程，如果线程的空闲时长超过keepAliveTime，那么该线程就会被终止。
unit:keepAliveTime的时间单位.
workQueue:The queue to use for holding tasks before they are executed. This queue will hold only the Runnable tasks submitted by the execute method.有3种排队策略。1)直接创建线程，不排队等待,比如SynchronousQueue; 2)无界队列LinkedBlockingQueue; 3)有界队列ArrayBlockingQueue;
threadFactory:如何创建线程，可以知道线程的名称、分组、优先级、状态等。
拒绝策略:当Executor关闭时，或者超过最大线程数或者队列容量的时候，就会丢弃任务，至于怎么丢弃，就取决于设置的丢弃策略。1)默认是AbortPolicy,直接抛出RejectedExecutionException异常; 2)CallerRunsPolicy 3)DiscardPolicy; 4)DiscardOldestPolicy

除了上诉的参数之外，还可以设置beforeExecute和afterExecute两个Hook方法。

常见的队列包括:

ArrayBlockingQueue：一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。
DelayQueue：阻塞的是其内部元素，DelayQueue中的元素必须实现 java.util.concurrent.Delayed接口，该接口只有一个方法就是long getDelay(TimeUnit unit)，返回值就是队列元素被释放前的保持时间，如果返回0或者一个负值，就意味着该元素已经到期需要被释放，此时DelayedQueue会通过其take()方法释放此对象，DelayQueue可应用于定时关闭连接、缓存对象，超时处理等各种场景；
LinkedBlockingQueue：阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量。它的内部实现是一个链表。
PriorityBlockingQueue：一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注意，PriorityBlockingQueue中允许插入null对象。所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就是按照我们对这个接口的实现来定义的。
SynchronousQueue：队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。

扩展例子：

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
    private boolean isPaused;
    private ReentrantLock pauseLock = new ReentrantLock();
    private Condition unpaused = pauseLock.newCondition();
 
    public PausableThreadPoolExecutor(...) { super(...); }
 
    protected void beforeExecute(Thread t, Runnable r) {
      super.beforeExecute(t, r);
      pauseLock.lock();
      try {
        while (isPaused) unpaused.await();
      } catch (InterruptedException ie) {
        t.interrupt();
      } finally {
        pauseLock.unlock();
      }
    }
 
    public void pause() {
      pauseLock.lock();
      try {
        isPaused = true;
      } finally {
        pauseLock.unlock();
      }
    }
 
    public void resume() {
      pauseLock.lock();
      try {
        isPaused = false;
        unpaused.signalAll();
      } finally {
        pauseLock.unlock();
     }
    }
 }

内部有个私有的Worker类，扩展自AbstractQueuedSynchronizer，实现了Runnable接口。然后通过HashSet来实现池。

类型

CachedThreadPool

Executors.newCachedThreadPool()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DKgEZdxm-1569571646792)(http://note.youdao.com/yws/res/59358/5C404A8CAECA4130A72532EED328D593)]

它是一个可以无限扩大的线程池；
它比较适合处理执行时间比较小的任务；
corePoolSize为0，maximumPoolSize为无限大，意味着线程数量可以无限大；
keepAliveTime为60S，意味着线程空闲时间超过60S就会被杀死；
采用SynchronousQueue装等待的任务，这个阻塞队列没有存储空间，这意味着只要有请求到来，就必须要找到一条工作线程处理他，如果当前没有空闲的线程，那么就会再创建一条新的线程。

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

FixedThreadPool

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uZBkVn6n-1569571646794)(http://note.youdao.com/yws/res/59368/06120A32F1B54DFBB01E2799B05B5705)]

它是一种固定大小的线程池；
corePoolSize和maximunPoolSize都为用户设定的线程数量nThreads；
keepAliveTime为0，意味着一旦有多余的空闲线程，就会被立即停止掉,但这里keepAliveTime无效；
阻塞队列采用了LinkedBlockingQueue，它是一个无界队列；
由于阻塞队列是一个无界队列，因此永远不可能拒绝任务；由于采用了无界队列，实际线程数量将永远维持在nThreads，因此maximumPoolSize和keepAliveTime将无效。

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

SingleThreadPool

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fienvdUE-1569571646795)(http://note.youdao.com/yws/res/59374/27B69A401C5F4754B3B5B59C806BA9B2)]

它只会创建一条工作线程处理任务；
采用的阻塞队列为LinkedBlockingQueue

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

WorkStealingPool

基于ForkJoin实现的多队列的并行执行的线程池。

SingleThreadScheduledExecutor

一个线程，可以

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
}
    
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,new DelayedWorkQueue());
}

  /**
     * A wrapper class that exposes only the ScheduledExecutorService
     * methods of a ScheduledExecutorService implementation.
     */
    static class DelegatedScheduledExecutorService
            extends DelegatedExecutorService
            implements ScheduledExecutorService {
        private final ScheduledExecutorService e;
        DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
            super(executor);
            e = executor;
        }
        public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
            return e.schedule(command, delay, unit);
        }
        public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
            return e.schedule(callable, delay, unit);
        }
        public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
            return e.scheduleAtFixedRate(command, initialDelay, period, unit);
        }
        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
            return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
        }
    }

ScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize) {
  super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
        new DelayedWorkQueue());
}

Dubbo

实现了4种线程池，4种线程池的丢弃策略都是AbortPolicyWithReport。

LimitedThreadPool

public class LimitedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        String name = url.getParameter(THREAD_NAME_KEY, DEFAULT_THREAD_NAME);
        int cores = url.getParameter(CORE_THREADS_KEY, DEFAULT_CORE_THREADS);  //0
        int threads = url.getParameter(THREADS_KEY, DEFAULT_THREADS); //200
        int queues = url.getParameter(QUEUES_KEY, DEFAULT_QUEUES); //0
        return new ThreadPoolExecutor(cores, threads, Long.MAX_VALUE, TimeUnit.MILLISECONDS,
                queues == 0 ? new SynchronousQueue<Runnable>() :
                        (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                        : new LinkedBlockingQueue<Runnable>(queues)),
                new NamedInternalThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }

}

最大的区别在于keepAliveTime的参数由默认的60L设置为Long.MAX_VALUE，也就是相当于无限长,即对已创建的线程永远不进行回收。

FixedThreadPool

public class FixedThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        String name = url.getParameter(THREAD_NAME_KEY, DEFAULT_THREAD_NAME);
        int threads = url.getParameter(THREADS_KEY, DEFAULT_THREADS); //200
        int queues = url.getParameter(QUEUES_KEY, DEFAULT_QUEUES); //0
        return new ThreadPoolExecutor(threads, threads, 0, TimeUnit.MILLISECONDS,
                queues == 0 ? new SynchronousQueue<Runnable>() :
                 (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                : new LinkedBlockingQueue<Runnable>(queues)),
                new NamedInternalThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }

}

默认200个线程同时启动，也不会过期，如果没设置队列大小，那么同时就只能支持200个并发任务。

CachedThreadPool

@Override
public Executor getExecutor(URL url) {
        String name = url.getParameter(THREAD_NAME_KEY, DEFAULT_THREAD_NAME);
        int cores = url.getParameter(CORE_THREADS_KEY, DEFAULT_CORE_THREADS); //0
        int threads = url.getParameter(THREADS_KEY, Integer.MAX_VALUE); 
        int queues = url.getParameter(QUEUES_KEY, DEFAULT_QUEUES); //0
        int alive = url.getParameter(ALIVE_KEY, DEFAULT_ALIVE); //60s
        return new ThreadPoolExecutor(cores, threads, alive, TimeUnit.MILLISECONDS,
                queues == 0 ? new SynchronousQueue<Runnable>() :
                        (queues < 0 ? new LinkedBlockingQueue<Runnable>()
                                : new LinkedBlockingQueue<Runnable>(queues)),
                new NamedInternalThreadFactory(name, true), new AbortPolicyWithReport(name, url));
    }

EagerThreadPool

/**
 * EagerThreadPool
 * When the core threads are all in busy,
 * create new thread instead of putting task into blocking queue.
 */
public class EagerThreadPool implements ThreadPool {

    @Override
    public Executor getExecutor(URL url) {
        String name = url.getParameter(THREAD_NAME_KEY, DEFAULT_THREAD_NAME);
        int cores = url.getParameter(CORE_THREADS_KEY, DEFAULT_CORE_THREADS);
        int threads = url.getParameter(THREADS_KEY, Integer.MAX_VALUE);
        int queues = url.getParameter(QUEUES_KEY, DEFAULT_QUEUES);
        int alive = url.getParameter(ALIVE_KEY, DEFAULT_ALIVE);

        // init queue and executor
        TaskQueue<Runnable> taskQueue = new TaskQueue<Runnable>(queues <= 0 ? 1 : queues);
        EagerThreadPoolExecutor executor = new EagerThreadPoolExecutor(cores,
                threads,
                alive,
                TimeUnit.MILLISECONDS,
                taskQueue,
                new NamedInternalThreadFactory(name, true),
                new AbortPolicyWithReport(name, url));
        taskQueue.setExecutor(executor);
        return executor;
    }
}


public class TaskQueue<R extends Runnable> extends LinkedBlockingQueue<Runnable> {

    private static final long serialVersionUID = -2635853580887179627L;

    private EagerThreadPoolExecutor executor;

    public TaskQueue(int capacity) {
        super(capacity);
    }

    public void setExecutor(EagerThreadPoolExecutor exec) {
        executor = exec;
    }

    @Override
    public boolean offer(Runnable runnable) {
        if (executor == null) {
            throw new RejectedExecutionException("The task queue does not have executor!");
        }

        int currentPoolThreadSize = executor.getPoolSize();
        // have free worker. put task into queue to let the worker deal with task.
        if (executor.getSubmittedTaskCount() < currentPoolThreadSize) {
            return super.offer(runnable);
        }

        // return false to let executor create new worker. 此处直接触发创建新线程。
        if (currentPoolThreadSize < executor.getMaximumPoolSize()) {
            return false;
        }

        // currentPoolThreadSize >= max
        return super.offer(runnable);
    }

    /**
     * retry offer task
     *
     * @param o task
     * @return offer success or not
     * @throws RejectedExecutionException if executor is terminated.
     */
    public boolean retryOffer(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
        if (executor.isShutdown()) {
            throw new RejectedExecutionException("Executor is shutdown!");
        }
        return super.offer(o, timeout, unit);
    }
}

但所有的core线程都忙时，直接创建新的线程，而不是放入队列中。JDK这种情况下默认是放入队列，支到队列满了之后，才会新建线程。

AbortPolicyWithReport：

...
 @Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        String msg = String.format("Thread pool is EXHAUSTED!" +
                " Thread Name: %s, Pool Size: %d (active: %d, core: %d, max: %d, largest: %d), Task: %d (completed: "
                + "%d)," +
                " Executor status:(isShutdown:%s, isTerminated:%s, isTerminating:%s), in %s://%s:%d!",
            threadName, e.getPoolSize(), e.getActiveCount(), e.getCorePoolSize(), e.getMaximumPoolSize(),
            e.getLargestPoolSize(),
            e.getTaskCount(), e.getCompletedTaskCount(), e.isShutdown(), e.isTerminated(), e.isTerminating(),
            url.getProtocol(), url.getIp(), url.getPort());
        logger.warn(msg);
        dumpJStack();
        throw new RejectedExecutionException(msg);
    }
    ...

打印线程池满了的告警日志，然后dump堆栈，然后抛出异常。

正说杂谈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
ThreadPoolExecutor

作用：大量异步任务的场景下，可以提升性能，避免了每个任务都要分配一个线程带来的资源消耗。提供管理资源的能力，包括统计当前的线程使用情况，任务的各种状态统计(已完成的任务数量、已提交的任务数量、排队的任务数量等)参数：corePoolSize:池中固定的线程数量，当然也和创建时的策略有关，取决于是prestartCoreThread还是prestartAllCoreThreads，是一...
复制链接

扫一扫