Java并发线程池底层原理剖析和源码分析

swadian2008

已于 2022-05-22 16:26:32 修改

阅读量308

点赞数

分类专栏：并发编程文章标签： Java线程池线程池线程池源码分析

于 2022-05-22 16:23:37 首次发布

本文链接：https://blog.csdn.net/swadian2008/article/details/124766424

版权

并发编程专栏收录该内容

41 篇文章 5 订阅

订阅专栏

一、线程和线程池的效率对比

二、Java线程池

三、线程池源码分析

四、ScheduledThreadPoolExecutor源码分析

一、线程和线程池的效率对比

使用线程方式执行程序

/***
 * 使用线程的方式去执行程序
 */
public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Long start = System.currentTimeMillis();
        final Random random = new Random();
        final List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 100000; i++) {
            Thread thread = new Thread(() -> list.add(random.nextInt()));
            thread.start();
            thread.join(); // 阻塞主线程，知道所有线程执行完成
        }
        System.out.println("时间：" + (System.currentTimeMillis() - start)+ " list大小：" + list.size());
    }
}

/***
 * 使用线程池执行
 */
public class ThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        Long start = System.currentTimeMillis();
        final Random random = new Random();
        final List<Integer> list = new ArrayList<Integer>();
        ExecutorService executorService = Executors.newSingleThreadExecutor(); // 线程复用
        for (int i = 0; i < 100000; i++) {
            executorService.execute(() -> list.add(random.nextInt()));
        }
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);// 阻塞，等各子线程都运行完毕后再执行
        System.out.println("时间：" + (System.currentTimeMillis() - start) + " list大小：" + list.size());
    }
}

可以发现，使用线程池去执行程序，效率要远远高于单个线程。

主要原因在于，使用单个线程的方式去执行程序，会导致线程重复创建且无法复用，使用线程池方式，可以实现线程复用，整个过程只创建了两个线程，即主线程和线程池中线程，线程池在执行任务的时候，并不会再重新创建线程(源码分析中会详细说明)。

二、Java线程池

常见的线程池有四种。

newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制最大并发数，超出的线程将在队列中等待。
newScheduledThreadPool 创建一个定时线程池，支持定时及周期性的执行任务。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有的任务按照指定顺序执行(FIFO,LIFO)。

ScheduledThreadPool 源码后边分析，其他三种线程池的对比图示如下：

线程池执行原理图示：

三、线程池源码分析

线程池源码流程图

接下来，分析源码。首先从使用线程池开始

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) {
        // 三种线java程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();//快
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);//慢
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();//最慢
        // 自定义拒绝策略
        RejectedExecutionHandler rejectedExecutionHandler = new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                try {
                    // 核心改造点，由 Blockingqueue 的offer改成put阻塞方法
                    executor.getQueue().put(r);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // 自定义线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
                0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(10), rejectedExecutionHandler);
        for (int i = 1; i <= 100; i++) {
            threadPoolExecutor.execute(new MyTask(i));
        }
    }
}

/***
 * 模拟项目代码
 */
class MyTask implements Runnable {
    int i = 0;
    public MyTask(int i) {
        this.i = i;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程，正在执行第" + i + "个任务");
        try {
            Thread.sleep(3000L);//模拟业务处理逻辑
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在代码中，我们使用到了线程池的创建类

public ThreadPoolExecutor(int corePoolSize,        // 核心线程数量
                              int maximumPoolSize, // 最大线程数量
                              long keepAliveTime,  // 存活时间
                              TimeUnit unit,       // 时间单位
                              BlockingQueue<Runnable> workQueue,   // 阻塞队列
                              ThreadFactory threadFactory,         // 线程工厂
                              RejectedExecutionHandler handler) {  // 拒绝策略
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

然后调用到了ThreadPoolExecutor的核心方法execute()，源码如下：

public void execute(Runnable command) { // 提交优先级
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // 1-判断是否小于核心线程数
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { // 2-如果是运行状态，放入对列
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command)) // 非运行状态，去除
                reject(command); // 决绝策略
            else if (workerCountOf(recheck) == 0)
                // 判断当前工作线程池数是否为0
                // 如果是创建一个null任务，任务在堵塞队列存在了就会从队列中取出
                // 意义,保证线程池在running状态必须有一个任务在执行
                addWorker(null, false); 
        }
        else if (!addWorker(command, false)) // 3-创建临时线程
            reject(command); // 4-执行拒绝策略
    }

如果满足线程池执行任务要求，会调用addWorker()方法，创建一个线程，然后去队列中获取任务，有关Worker的继承关系图如下

addWorker()方法源码

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:  // goto写法 用于重试
        for (;;) { // 1-参数校验循环
            int c = ctl.get();
            // 获取当前线程状态
            int rs = runStateOf(c);
            // 线程状态非运行状态&&非shutdown状态,任务为空,队列非空,不能新增线程
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty())) // 状态判断
                return false;
            for (;;) {
                int wc = workerCountOf(c); 
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize)) // 判断是否超出线程数量
                    return false;
                if (compareAndIncrementWorkerCount(c)) // 如果增加线程成功，退出循环
                    break retry;
                c = ctl.get();  // Re-read ctl
                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 {
            //  Worker为内部类,里边封装了线程和任务,通过threadfactory创建线程
            w = new Worker(firstTask); // 2-创建一个工作线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock; // 上锁
                mainLock.lock();
                try {
                    // 重新获取当前线程状态
                    int rs = runStateOf(ctl.get());
                    // 继续判断状态，小于shutdown就是running状态
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) { 
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);  // 添加到工作线程集合(Set)
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s; // 记录最大线程数
                        workerAdded = true;  // 把标记设为true
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) { // 如果标记为true,调用线程start()方法
                    t.start();   // 3-会去执行run()方法
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w); // 4-失败回退 从wokers移除w 线程数减1 尝试结束线程池
        }
        return workerStarted;
    }

当执行到start()方法时，会调用到内部类Worker中的run()方法

runWorker()方法中的逻辑如下

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts 允许中断，Worker创建时不允许中断(创建时会带一个标记)
        boolean completedAbruptly = true;
        try {
            // 1-非常关键：执行优先，只有任务为空，才会去从队列中获取任务 getTask()
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task); // 空方法，可以重写，在线程池执行前执行
                    Throwable thrown = null;
                    try { // task为任务，而非线程
                        task.run(); // 2-线程池里边执行的是run()方法的调用，而非多个start()
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);  // 空方法，可以重写，在线程池执行后执行
                    }
                } finally {
                    task = null;
                    w.completedTasks++; // 完成任务数+1
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly); // 4-工作线程的退出逻辑，线程复用
        }
    }

这里有一个细节，自定义的run()方法一定要做try catch ，不要直接抛异常，因为run()中的异常会被吃掉，并不会抛出来。最后，看一下 getTask() 方法，这个方法负责从阻塞队列中获取任务

private Runnable getTask() { // 从队列中获取任务并返回
        boolean timedOut = false; // Did the last poll() time out?
        for (;;) {
            int c = ctl.get();
            // 获取线程池运行状态
            int rs = runStateOf(c);
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            // 重新获取工作线程数
            int wc = workerCountOf(c);
            // timed是标志超时销毁,核心线程池也是可以被销毁的
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try { // 核心：移除并返问队列头部的元素,如果为空,take()会阻塞
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

四、ScheduledThreadPoolExecutor源码分析

首先，对ScheduledThreadPoolExecutor具体使用示例如下

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ScheduledThreadPoolExecutorExample {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(5);
        Task task = new Task("Task");
        System.out.println("Created : " + task.getName());
        // executor.schedule(task, 2, TimeUnit.SECONDS); // 延迟2s执行一次任务
        // executor.scheduleWithFixedDelay(task, 0, 2, TimeUnit.SECONDS); // 周期性执行，任务执行时间(3s)+延迟执行时间(2s)=5s
        executor.scheduleAtFixedRate(task, 0, 1, TimeUnit.SECONDS);// 稳定定时器(固定任务时间3s)
    }
}

// 任务
class Task implements Runnable {
    private String name;
    public Task(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void run() {
        System.out.println("Executing : " + name + ", Current Seconds : " + new Date().getSeconds());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

示例中，最后调用了scheduleAtFixedRate()方法，延迟周期性执行任务，scheduleAtFixedRate()方法源码如下

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0)
            throw new IllegalArgumentException();
        // 使用的内部类ScheduledFutureTask，Task中具备run()方法
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(period));
        // 空实现，拓展方法，可以对线程池进行拓展
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        // 具体执行，相当于其他线程的execute()方法
        delayedExecute(t);
        return t;
    }

跟进delayedExecute()方法

private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            // 与ThreadPoolExecutor不同，这里直接把任务加入延迟队列
            super.getQueue().add(task); 
            // 如果当前状态无法执行任务，移除任务，并把任务标记设置为取消
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                // 增加Worker，确保提交的任务能够被执行
                ensurePrestart();
        }
    }

继续跟进ensurePrestart()方法，可以发现，真正执行任务时，还是使用的addWorker()方法，在该方法中会生成线程，然后调用start()方法，之后会执行任务的run()方法

void ensurePrestart() {
        int wc = workerCountOf(ctl.get());
        if (wc < corePoolSize)
            addWorker(null, true);
        else if (wc == 0)
            addWorker(null, false);
    }

在该线程池中，任务不再Worker的封装类，而是上边提到的ScheduledFutureTask，所以需要跟进到ScheduledFutureTask中的run()方法

    public void run() {
            // 1-判断是否是周期性任务
            boolean periodic = isPeriodic(); 
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            // 2-如果非周期性任务直,接调用run运行
            else if (!periodic) 
                ScheduledFutureTask.super.run();
            // 3-如果成功runAndRest，则设置下次运行时间并调用reExecutePeriodic。
            else if (ScheduledFutureTask.super.runAndReset()) {
                // 时间设置          
                setNextRunTime();
                // 重新将任务(outerTask)放到工作队列中
                reExecutePeriodic(outerTask);
            }
        }

跟进时间设置的方法setNextRunTime()，线程池设置的参数不同，延迟时间的处理也不同

    private void setNextRunTime() {
            long p = period;
            // fixed‐rate模式，时间设置为上一次时间+p。
            if (p > 0)
                time += p;
            // fixed‐delay模式，计算下一次任务可以被执行的时间
            else 
                time = triggerTime(-p);
        }

返回来，跟进 reExecutePeriodic() 方法

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(true)) {
            super.getQueue().add(task);  // 把任务重新放入延迟对列
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
                // 再次去执行任务
                ensurePrestart();
        }
    }

这里重点跟一下

super.getQueue().add(task);  // 把任务重新放入延迟对列

Runnable任务添加的逻辑如下：

    public boolean offer(Runnable x) {
            if (x == null)
                throw new NullPointerException();
            RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                int i = size;
                if (i >= queue.length)
                    // 容量扩增50%。
                    grow();
                size = i + 1;
                if (i == 0) {
                    queue[0] = e;
                    setIndex(e, 0);
                } else {
                    // 使用堆排序
                    siftUp(i, e);
                }
                // 如果新加入的元素成为了堆顶,则之前的leader就无效了,设置为Null
                if (queue[0] == e) {
                    leader = null;
                    // 由于原先leader已经无效被设置为null了,这里随便唤醒一个线程(未必是原先的leader)来取走堆顶任务。
                    available.signal();
                }
            } finally {
                lock.unlock();
            }
            return true;
        }

offer()中，有一个堆排序的siftUp()方法，跟进去看下

        private void siftUp(int k, RunnableScheduledFuture<?> key) {
            while (k > 0) {
                // 1-获取父节点
                int parent = (k - 1) >>> 1;
                RunnableScheduledFuture<?> e = queue[parent];
                // 2-如果key节点的执行时间大于父节点的执行时间，无需排序
                if (key.compareTo(e) >= 0)
                    break;
                // 3-key节点的执行时间小于父节点的执行时间，需要把父节点移到后面
                queue[k] = e;
                setIndex(e, k);
                k = parent;
            }
            // 4-把key设置到排序后的位置
            queue[k] = key;
            setIndex(key, k);
        }

以上逻辑可以理解为：循环的根据key节点与它的父节点来判断，如果key节点的执行时间小于父节点，则将两个节点交换，使执行时间靠前的节点排列在队列的前面。其实就是一个树形的最小堆结构，在最小堆结构中父节点一定小于子节点

在DelayQueue内部封装了一个PriorityQueue，它会根据time的先后时间排序（time小的排在前面），若time相同则根据sequenceNumber排序（ sequenceNumber小的排在前面）。

swadian2008

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java并发线程池底层原理剖析和源码分析

目录一、线程和线程池的效率对比二、Java线程池三、线程池源码分析四、ScheduledThreadPoolExecutor源码分析一、线程和线程池的效率对比使用线程方式执行程序/*** * 使用线程的方式去执行程序 */public class ThreadTest { public static void main(String[] args) throws InterruptedException { Long start = System.
复制链接

扫一扫