JUC线程池

最新推荐文章于 2024-04-04 01:30:19 发布

HryReal

最新推荐文章于 2024-04-04 01:30:19 发布

阅读量248

点赞数

分类专栏：多线程源码分析文章标签： JUC 线程池 ThreadpoolExecutor

本文链接：https://blog.csdn.net/qq_33394088/article/details/79068863

版权

多线程源码分析专栏收录该内容

20 篇文章 0 订阅

订阅专栏

线程池ThreadpoolExecutor介绍

1.线程的状态及表示

在了解线程池的原理之前，必须先了解一下知识。

线程的状态在ThreadpoolExecutor的表示：

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

RUNNING – 对应的高3位值是111。
SHUTDOWN – 对应的高3位值是000。
STOP – 对应的高3位值是001。
TIDYING – 对应的高3位值是010。
TERMINATED – 对应的高3位值是011。
ctl共包括32位。其中，高3位表示”线程池状态”，低29位表示”线程池中的任务数量”。

线程池各个状态之间的切换如下图所示：
1. RUNNING
(01) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。

(02) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态！
道理很简单，在ctl的初始化代码中(如下)，就将它初始化为RUNNING状态，并且”任务数量”初始化为0。
1. SHUTDOWN
(01) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。

(02) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
1. STOP
(01) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。

(02) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
1. TIDYING
(01) 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。

(02) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
1. TERMINATED
(01) 状态说明：线程池彻底终止，就变成TERMINATED状态。

(02) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

2.ThreadPoolExecutor数据结构

成员变量的含义：

workers

workers是HashSet类型，即它是一个Worker集合。而一个Worker对应一个线程，也就是说线程池通过workers包含了”一个线程集合”。当Worker对应的线程池启动时，它会执行线程池中的任务；当执行完一个任务后，它会从线程池的阻塞队列中取出一个阻塞的任务来继续运行。
workQueue

workQueue是BlockingQueue类型，即它是一个阻塞队列。当线程池中的线程数超过它的容量的时候，线程会进入阻塞队列进行阻塞等待。
通过workQueue，线程池实现了阻塞功能。
mainLock

mainLock是互斥锁，通过mainLock实现了对线程池的互斥访问。
corePoolSize和maximumPoolSize

corePoolSize是”核心池大小”，maximumPoolSize是”最大池大小”。它们的作用是调整”线程池中实际运行的线程的数量”。
例如，当新任务提交给线程池时(通过execute方法)。

– 如果此时，线程池中运行的线程数量< corePoolSize，则创建新线程来处理请求。

– 如果此时，线程池中运行的线程数量> corePoolSize，但是却< maximumPoolSize；则仅当阻塞队列满时才创建新线程。

如果设置的 corePoolSize 和 maximumPoolSize 相同，则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务。在大多数情况下，核心池大小和最大池大小的值是在创建线程池设置的；但是，也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 进行动态更改。
poolSize

poolSize是当前线程池的实际大小，即线程池中任务的数量。
allowCoreThreadTimeOut和keepAliveTime

allowCoreThreadTimeOut表示是否允许”线程在空闲状态时，仍然能够存活”；而keepAliveTime是当线程池处于空闲状态的时候，超过keepAliveTime时间之后，空闲的线程会被终止。
threadFactory

threadFactory是ThreadFactory对象。它是一个线程工厂类，”线程池通过ThreadFactory创建线程”。
handler

handler是RejectedExecutionHandler类型。它是”线程池拒绝策略”的句柄，也就是说”当某任务添加到线程池中，而线程池拒绝该任务时，线程池会通过handler进行相应的处理”。

3.ThreadPoolExecutor的源码分析

构造方法

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

Executors.defaultThreadFactory()是什么样的呢？

     DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            //通过SecurityManager得到线程组
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }
    }

说明：DefaultThreadFactory能够的到线程组

再来看一下defaultHandler的声明：

  private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();

    public static class AbortPolicy implements RejectedExecutionHandler {

        public AbortPolicy() { }

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

defualtHandler的拒绝策略是无论如何都抛出错误！！

至此，我们的构造方法已经了解清楚了，我们来看几个Executors调用构造方法构造线程池的例子：

Executors的newFixedThreadPool(int)方法：

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

看名字就知道他创建了一个固定大小的线程池，所以它的corePoolSize和maximumPoolSize属性一样，而且是传入LinkedBlockingQueue，无界的阻塞队列，存放多出来的线程。

Executors的newSingleThreadExecutor()方法：

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

看名字就知道他创建了一个大小为1的线程池，而且是无界的阻塞队列，存放多出来的线程。

添加任务

public void execute(Runnable command) {
    // 如果任务为null，则抛出异常。
    if (command == null)
        throw new NullPointerException();
    // 获取ctl对应的int值。该int值保存了"线程池中任务的数量"和"线程池状态"信息
    int c = ctl.get();
    // 当线程池中的任务数量 < "核心池大小"时，即线程池中少于corePoolSize个任务。
    // 则通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 当线程池中的任务数量 >= "核心池大小"时，
    // 而且，"线程池处于允许状态"时，则尝试将任务添加到阻塞队列中。
    if (isRunning(c) && workQueue.offer(command)) {
        // 再次确认“线程池状态”，若线程池异常终止了，则删除任务；然后通过reject()执行相应的拒绝策略的内容。
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 否则，如果"线程池中任务数量"为0，则通过addWorker(null, false)尝试新建一个线程，新建线程对应的任务为null。
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
    // 如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
    else if (!addWorker(command, false))
        reject(command);
}

说明：execute()的作用是将任务添加到线程池中执行。它会分为3种情况进行处理：

情况1 – 如果”线程池中任务数量” < “核心池大小”时，即线程池中少于corePoolSize个任务；此时就新建一个线程，并将该任务添加到线程中进行执行。

情况2 – 如果”线程池中任务数量” >= “核心池大小”，并且”线程池是允许状态”；此时，则将任务添加到阻塞队列中阻塞等待。在该情况下，会再次确认”线程池的状态”，如果”第2次读到的线程池状态”和”第1次读到的线程池状态”不同，则从阻塞队列中删除该任务。

情况3 – 非以上两种情况。在这种情况下，尝试新建一个线程，并将该任务添加到线程中进行执行。如果执行失败，则通过reject()拒绝该任务。

addWorker方法

“`
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 更新”线程池状态和计数”标记，即更新ctl。
for (;;) {
// 获取ctl对应的int值。该int值保存了”线程池中任务的数量”和”线程池状态”信息
int c = ctl.get();
// 获取线程池状态。
int rs = runStateOf(c);

    // 有效性检查
    if (rs >= SHUTDOWN &&
        ! (rs == SHUTDOWN &&
           firstTask == null &&
           ! workQueue.isEmpty()))
        return false;

    for (;;) {
        // 获取线程池中任务的数量。
        int wc = workerCountOf(c);
        // 如果"线程池中任务的数量"超过限制，则返回false。
        if (wc >= CAPACITY ||
            wc >= (core ? corePoolSize : maximumPoolSize))
            return false;
        // 通过CAS函数将c的值+1。操作失败的话，则退出循环。
        if (compareAndIncrementWorkerCount(c))
            break retry;
        c = ctl.get();  // Re-read ctl
        // 检查"线程池状态"，如果与之前的状态不同，则从retry重新开始。
        if (runStateOf(c) != rs)
            continue retry;
        // else CAS failed due to workerCount change; retry inner loop
    }
}

boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
// 添加任务到线程池，并启动任务所在的线程。
try {
    final ReentrantLock mainLock = this.mainLock;
    // 新建Worker，并且指定firstTask为Worker的第一个任务。
    w = new Worker(firstTask);
    // 获取Worker对应的线程。
    final Thread t = w.thread;
    if (t != null) {
        // 获取锁
        mainLock.lock();
        try {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 再次确认"线程池状态"
            if (rs < SHUTDOWN ||
                (rs == SHUTDOWN && firstTask == null)) {
                if (t.isAlive()) // precheck that t is startable
                    throw new IllegalThreadStateException();
                // 将Worker对象(w)添加到"线程池的Worker集合(workers)"中
                workers.add(w);
                // 更新largestPoolSize
                int s = workers.size();
                if (s > largestPoolSize)
                    largestPoolSize = s;
                workerAdded = true;
            }
        } finally {
            // 释放锁
            mainLock.unlock();
        }
        // 如果"成功将任务添加到线程池"中，则启动任务所在的线程。 
        if (workerAdded) {
            t.start();
            workerStarted = true;
        }
    }
} finally {
    if (! workerStarted)
        addWorkerFailed(w);
}
// 返回任务是否启动。
return workerStarted;

}
“`

说明：

addWorker(Runnable firstTask, boolean core) 的作用是将任务(firstTask)添加到线程池中，并启动该任务。

core为true的话，则以corePoolSize为界限，若”线程池中已有任务数量>=corePoolSize”，则返回false；core为false的话，则以maximumPoolSize为界限，若”线程池中已有任务数量>=maximumPoolSize”，则返回false。

addWorker()会先通过for循环不断尝试更新ctl状态，ctl记录了”线程池中任务数量和线程池状态”。

更新成功之后，再通过try模块来将任务添加到线程池中，并启动任务所在的线程。

从addWorker()中，我们能清晰的发现：线程池在添加任务时，会创建任务对应的Worker对象；而一个Workder对象包含一个Thread对象。(01) 通过将Worker对象添加到”线程的workers集合”中，从而实现将任务添加到线程池中。 (02) 通过启动Worker对应的Thread线程，则执行该任务。

关闭线程池

shutdown方法

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    // 获取锁
    mainLock.lock();
    try {
        // 检查终止线程池的“线程”是否有权限。
        checkShutdownAccess();
        // 设置线程池的状态为关闭状态。
        advanceRunState(SHUTDOWN);
        // 中断线程池中空闲的线程。
        interruptIdleWorkers();
        // 钩子函数，在ThreadPoolExecutor中没有任何动作。
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        // 释放锁
        mainLock.unlock();
    }
    // 尝试终止线程池
    tryTerminate();
}

HryReal

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC线程池

线程池ThreadpoolExecutor介绍1.线程的状态及表示在了解线程池的原理之前，必须先了解一下知识。线程的状态在ThreadpoolExecutor的表示： private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int
复制链接

扫一扫

专栏目录