线程池源码

Java并发工具类Executors详解

最新推荐文章于 2025-06-24 15:17:21 发布

hongzhily

最新推荐文章于 2025-06-24 15:17:21 发布

阅读量118

点赞数

CC 4.0 BY-SA版权

分类专栏： java源码文章标签：线程池 Executors ThreadPoolExecutor 源码

本文链接：https://blog.youkuaiyun.com/hongzhily/article/details/99217703

java源码专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了Java并发包下的工具类Executors，包括如何使用静态方法创建各种线程池，如固定线程数量、单一线程、具有缓存能力和定时任务的线程池。同时，深入探讨了ThreadPoolExecutor和ScheduledThreadPoolExecutor的内部实现机制。

Executors

Executors是concurrent包下的工具类，通过静态方法产生各种线程池

产生固定线程数量的线程池

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

产生只有一个线程的线程池

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

产生具有缓存能力的线程池，如果任务数量超过能力，可回收利用空闲的线程

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

产生具有定时任务或周期性任务的线程池

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

ThreadPoolExecutor

ThreadPoolExecutor是真正的线程池，构造方法有若干个参数

public ThreadPoolExecutor(
							  int corePoolSize, 
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize:
核心线程数，当前任务数量小于corePoolSize时，直接创建线程执行，当空闲时也不会被回收
maximumPoolSize：
最大线程数，当workQueue已满，并且maximumPoolSize>corePoolSize创建线程执行
keepAliveTime：
超过核心线程数量的线程的存活时间
unit：
超过核心线程数量的线程的存活时间的单位
workQueue：
任务等待队列
threadFactory：
线程工厂
handler：
异常处理策略，默认AbortPolicy，抛出异常

创建线程是调用addWorker方法，其核心是调用ThreadFactor产生一个线程

w = new Worker(firstTask);
final Thread t = w.thread;

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
        final Thread thread;
        Runnable firstTask;
        volatile long completedTasks;

        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
}

创建线程池如果不传入自定义线程工厂，会用默认的工厂

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

在defaultThreadFactory函数中直接new了一个线程

public Thread newThread(Runnable r) {
	Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);
    return t;
}

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，队列用的是delayedWorkQueue

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

加入任务时，会加入到延迟队列中，如果任务到达时间，就执行，否则阻塞