Java线程池底层原理

jakiechaipush

已于 2023-11-28 10:38:27 修改

阅读量892

点赞数 19

分类专栏： JUC 文章标签： java 开发语言

于 2023-11-28 10:23:51 首次发布

本文链接：https://blog.csdn.net/qq_43456605/article/details/134658606

版权

JUC 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

文章目录

1. 线程和现场池的对比

下面代码创建了100000个线程

public class Main {
    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() {
                @Override
                public void run() {
                    list.add(random.nextInt());
                }
            };
            thread.start();
            thread.join();
        }
        System.out.println("时间:" + (System.currentTimeMillis()-start));
        System.out.println("大小:" + list.size());
    }
}

在这里插入图片描述
使用了14s左右的时间执行

而下面代码则使用线程池

public class Main {
    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(new Runnable() {
         @Override
         public void run() {
             list.add(random.nextInt());
         } });
        }
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("时间:"+(System.currentTimeMillis()-start));
        System.out.println("大小:"+list.size());
    }
}

在这里插入图片描述
发现时间只需要97ms，性能得到了大大的提升，那为什么提升会如此大？原因是代码1使用了100000个线程，而代码2只使用到了1个线程，要知道线程的创建以及上下文切换都是十分消耗CPU资源的，而代码1大量的时间都花到了这部分上面。所以在这种场景下使用线程池会更快一些，但使用线程池一定会更快吗？看下面的代码：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService1 = Executors.newCachedThreadPool();
        ExecutorService executorService2 = Executors.newFixedThreadPool(10);
        ExecutorService executorService3 = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100; i++) {
            executorService3.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(300L);
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

上面代码我们分别用三个线程池来执行100个任务，执行结果可以发现，三个线程池由上到下速度越来越慢，前面我们代码知道了Executors.newSingleThreadExecutor这个线程池执行100000个任务的速度非常快，那为什么这里执行100个任务却这么慢呢。这时候我们就需要从我们执行的任务类型开始分析，首先从源码开始分析：

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

可以发现三个线程池底层都是基于ThreadPoolExecutor 这个类创建的，我们来重点分析一下这个类。

2. ThreadPoolExecutor分析

ThreadPoolExecutor的构造函数源码如下

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

corePoolSize：核心线程数，核心线程数是线程池中一直存在的线程数量，即使它们处于空闲状态
maximumPoolSize：最大线程数，最大线程数是线程池允许的最大线程数量，包括空闲和活动线程。
BlockingQueue：阻塞队列，存储我们要执行的任务
ThreadFactory：线程工厂，用来创建线程
keepAliveTime：线程生命周期

newCachedThreadPool

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

corePoolSize：核心线程数为0
maximumPoolSize：最大线程数为Integer.MAX_VALUE
线程生命周期：60s
可以发现newCachedThreadPool这个现场池没有核心线程，它返回一个可以根据需要创建新线程的线程池，但在先前构建的线程可用时将重用它们。它的特点主要如下：

动态线程数： newCachedThreadPool 创建一个具有可变大小的线程池，根据需要动态地创建新的线程。如果有可用的空闲线程，它将重用这些线程，否则将创建新线程。
无限制线程数：线程池的最大线程数理论上是无限的，因为它可以根据需要动态创建新线程。这可能会导致线程数在极端情况下无限增长，因此在某些情况下需要谨慎使用，以防止资源耗尽。
自动线程回收：如果某个线程在60秒内没有被使用（空闲状态），则该线程将被终止并从线程池中移除。这有助于自动释放系统资源。
适用于短生命周期的异步任务：适用于执行大量的、相对较短的任务，因为线程池会根据需要创建新线程，并在空闲一段时间后终止不再需要的线程。
不适用于长时间运行的任务：由于线程池的最大线程数理论上是无限的，不适用于长时间运行的任务，因为这可能导致线程数过多，从而影响性能。

newFixedThreadPool

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

corePoolSize：核心线程数为1
maximumPoolSize：最大线程数为10
线程生命周期：永久
LinkedBlockingQueue：阻塞队列的大小无限大

该线程池将一直保持指定数量的线程，即核心线程数，在任何时候都是活动的。如果有新的任务提交，而线程池中的线程数尚未达到核心线程数，将会创建新线程来处理任务。以下是 newFixedThreadPool 的主要特点：

固定线程数： newFixedThreadPool 创建一个具有固定数量线程的线程池，这个数量在创建线程池时被指定。
无限制的工作队列：线程池使用一个无界的工作队列（LinkedBlockingQueue）来保存等待执行的任务。这意味着如果任务提交速度超过了线程池处理任务的速度，任务将被放入队列中等待执行，而不会导致线程数继续增加。
适用于长时间运行的任务：适用于执行长时间运行的任务，因为线程池中的线程数是固定的，不会根据任务的数量而动态变化。
控制资源占用：由于线程数是固定的，可以更好地控制系统资源的占用，不会因为任务数量过多而导致过度的线程创建。

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

corePoolSize：核心线程数为1
maximumPoolSize：最大线程数为1
线程生命周期：永久
LinkedBlockingQueue：阻塞队列的大小无限大

是一个只包含单个线程的线程池。该线程池确保所有任务按照它们被提交的顺序执行，并且在任何时候都只有一个线程处于活动状态。以下是 newSingleThreadExecutor 的主要特点：

单线程执行： newSingleThreadExecutor 创建一个只有一个线程的线程池。这意味着所有任务都将按照它们被提交的顺序在同一个线程中执行。
无限制的工作队列：类似于 newFixedThreadPool，newSingleThreadExecutor 也使用一个无界的工作队列（LinkedBlockingQueue）来保存等待执行的任务。
适用于需要顺序执行的任务：适用于需要按照提交顺序执行的任务，确保任务之间不会并发执行。
线程异常处理：由于只有一个线程，因此可以更容易地捕获和处理线程抛出的异常。

下面就来解释一下为什么上面不同的线程池执行速度会不同，对于newCachedThreadPool，它会根据需要创建很多线程，也会出现线程复用的情况所以它执行速度很快，然后newFixedThreadPool它只创建了10个线程去执行100个任务，速度会比newCachedThreadPool慢，最后是newSingleThreadExecutor它只有一个线程执行100个任务所以它是最慢的。这就是从线程池角度出发，为什么会出现上面不同线程池执行速度不同的情况。然后从任务的角度出发，对于newSingleThreadExecutor它前面执行100000个任务，由于任务很小（代码可以看出）能在瞬间完成，这个唯一的线程能不断复用，所以速度会非常快。而对于Mytask任务，该任务里面执行了sleep()函数，算一个比较大的任务，所以单一线程会执行非常慢。这就是出现前面情况的原因。

注意：阿里规范是不推荐使用JDK提供的线程池的

线程资源无限制： Executors.newCachedThreadPool 和 Executors.newFixedThreadPool 等工厂方法创建的线程池，由于没有明确地设置最大线程数或工作队列容量，可能会导致线程资源无限制地增长，从而影响系统的稳定性。
无法控制线程池的最大大小：这些工厂方法创建的线程池，虽然能够满足任务提交需求，但是它们没有提供直接的方式来设置合理的最大线程数，特别是在并发任务量剧增的情况下。
无界队列可能导致内存溢出： Executors.newCachedThreadPool 和 Executors.newFixedThreadPool 默认使用无界的任务队列，如果任务提交速度远远快于线程池处理速度，会导致队列无限增长，最终可能导致内存溢出。

相反，阿里规范推荐使用ThreadPoolExecutor手动创建线程池，以便有更多的控制权。通过手动配置 ThreadPoolExecutor 的参数，可以限制线程的数量、设置合理的队列大小，并明确定义饱和策略。这样可以更好地适应不同的业务场景和负载情况，提高系统的稳定性和可维护性。

3. ThreadPoolExecutor源码详解

如下面我们自定义了一个线程池来执行前面的Mytask任务，现场池有10个核心线程，20个最大现场数，阻塞队列的大小为10个，仔细观察执行结果：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(
                10,
                20,
                0L, 
                TimeUnit.MILLISECONDS, 
                new LinkedBlockingQueue<Runnable>(10));//自定义线程
        for (int i = 0; i < 100; i++) {
            threadPoolExecutor.execute(new MyTask(i));
        }
    }
}

我们发现执行任务是无序的
出现了拒绝任务的错误

为了分析出现上面两个情况的原因，我们要深入ThreadPoolExecutor的源码进行分析。

ThreadPoolExecutor类结构图

在这里插入图片描述

Executor类

Executor 接口是 Java 并发框架的一部分，它定义了一种执行任务的简单机制。

public interface Executor {
  /**
     * 在将来的某个时间执行给定的命令。
     * 该命令可以在新线程、池化线程或调用线程中执行，这由 Executor 的实现决定。
     *
     * @param command 要执行的命令
     * @throws RejectedExecutionException 如果不能接受该任务，则抛出此异常。
     * @throws NullPointerException 如果命令为 null，则抛出此异常。
     */
    void execute(Runnable command);
}

ExecutorService

ExecutorService 是 Executor 接口的子接口，它扩展了 Executor 的功能，提供了更丰富的任务执行和管理功能。ExecutorService 主要用于执行和管理异步任务，可以提交任务、取消任务、获取任务执行的结果等。

public interface ExecutorService extends Executor {
//平缓地关闭执行器，不再接受新任务，但会等待已经提交的任务执行完成。
    void shutdown();
    //立即关闭执行器，尝试停止所有正在执行的任务，并返回等待执行的任务列表。
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
     //提交一个可调用的任务，并返回一个表示该任务未来结果的 Future。
    <T> Future<T> submit(Callable<T> task);
    //提交一个可运行的任务，并返回一个表示该任务未来结果的 Future。
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    //执行给定的任务列表，返回一个包含 Future 的列表，表示任务的未来结果。在所有任务完成之前，此方法将阻塞。
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

AbstractExecutorService

AbstractExecutorService 是 ExecutorService 接口的抽象实现，它提供了一些基本的执行器服务功能，使得实现 ExecutorService 接口的类能够更容易地实现这个接口。

public abstract class AbstractExecutorService implements ExecutorService {
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

}

ThreadPoolExecutor

我们在定义完ThreadPoolExecutor后会调用excute方法去执行任务

execute

public void execute(Runnable command) { 
        //任务为空抛出空指针异常
        if (command == null)
            throw new NullPointerException();
            //获取当前线程池的控制状态（ctl 是 AtomicInteger 类型的变量，用于表示线程池的状态和工作线程数）。
        int c = ctl.get();
        //检查当前工作线程数量是否小于核心线程数 (corePoolSize)。如果是，尝试通过 addWorker 方法增加一个核心线程来执行任务。如果成功添加了线程，则直接返回，任务将由新线程执行。如果无法添加线程，则重新获取控制状态并继续执行后续逻辑。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果无法添加核心线程，检查线程池是否处于运行状态（isRunning(c)）。如果是，并且成功将任务放入工作队列 (workQueue.offer(command))，则继续执行。
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //如果此时线程池不再运行，并且任务无法从队列中移除，说明任务将被拒绝（reject）。
            if (! isRunning(recheck) && remove(command))
                reject(command);
                //如果此时线程池中没有工作线程，则尝试添加一个非核心线程（addWorker(null, false)）。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果无法将任务添加到工作队列中，则尝试通过 addWorker 方法添加一个非核心线程来执行任务。如果无法添加非核心线程，则说明线程池已经饱和，任务将被拒绝。
        else if (!addWorker(command, false))
            reject(command);
    }

在这里插入图片描述

1-10的任务可以交给核心线程去执行
11-20的任务会放在阻塞队列中
21-30的任务由于阻塞队列满了，所以会创建10个非核心线程执行
31的任务无法处理了直接执行拒绝策略

在这里插入图片描述

以上就是为什么会出现拒绝错误的问题

addWorker
上面execute源码我们可以看出多次调用了addWorker，这个方法用于尝试添加一个新的工作线程到线程池，下面我们来详细分析一下这个方法。

 private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        //首先，使用一个无限循环标签retry开始迭代。在每次迭代中，首先获取当前的控制状态c和运行状态rs。
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            // 然后，检查线程池的运行状态是否已经达到 SHUTDOWN 或更高，并且工作队列为空。如果是，说明线程池已经关闭或正在关闭，并且工作队列已经为空，此时不应该再添加新的线程，返回false。
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
//在内层循环中，检查工作线程数是否达到线程池容量的上限（CAPACITY）或者达到了当前设置的核心线程数或最大线程数上限。如果工作线程数已经超过上限，则直接返回 false，不再添加新的线程。
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                    //如果可以增加工作线程数，通过 compareAndIncrementWorkerCount(c) 尝试原子地增加工作线程数。如果成功增加，则跳出外层循环，返回 true 表示成功添加了工作线程。如果增加失败，重新获取控制状态 c 并检查运行状态是否发生了变化。如果运行状态发生变化，重新进入外层循环进行重试。
                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
            }
        }
        //workerStarted 和 workerAdded 是用于记录是否成功启动工作线程的标志。
        boolean workerStarted = false;
        boolean workerAdded = false;
        //创建一个Worker 对象，Worker 是 ThreadPoolExecutor中的内部类，表示线程池中的工作线程。
        Worker w = null;
        try {
        //首先通过new Worker(firstTask) 创建一个新的工作线程对象，final Thread t = w.thread; 获取该工作线程的Thread对象。
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
            //获取mainLock，这是线程池的主锁，确保在更新线程池状态和工作线程集合时是同步的。
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
           //在获取锁的情况下，再次检查线程池的运行状态 rs。只有在线程池处于运行状态（SHUTDOWN 状态及以上），或者线程池处于关闭状态且提交的任务为 null 时，才允许添加工作线程。
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        //在获取锁的情况下，再次检查线程池的运行状态 rs。只有在线程池处于运行状态（SHUTDOWN 状态及以上），或者线程池处于关闭状态且提交的任务为 null 时，才允许添加工作线程。
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                //如果成功添加了工作线程（非核心线程），调用 t.start() 启动工作线程，并将 workerStarted 设置为 true
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
 }

简而言之上面代码就是做了一件事，检查现场池的状态，然后根据状态是否考虑将工作现场加入到现场池中开始执行任务。执行任务调用的是t.start()方法，默认执行现场的Worker类的run方法，如下

public void run() {
            runWorker(this);
        }

run方法中调用了一个runWorker方法

final void runWorker(Worker w) {
//Thread wt = Thread.currentThread(); 获取当前工作线程的 Thread 对象。
        Thread wt = Thread.currentThread();
        //Runnable task = w.firstTask; 获取工作线程的初始任务。
        Runnable task = w.firstTask;
        //w.firstTask = null; 清空工作线程的初始任务。（用于线程复用）
        w.firstTask = null;
        //w.unlock(); 解锁工作线程，允许被中断。
        w.unlock(); // allow interrupts
        //用于标记工作线程是否突然终止，默认为 true。
        boolean completedAbruptly = true;
        try {
        //这是一个主要的工作循环，该循环不断从工作队列中取任务并执行
            while (task != null || (task = getTask()) != null) {
            //获取工作线程的独占锁，确保在执行任务过程中是独占锁的
                w.lock();
                //判断线程池是否正在关闭。如果线程池处于 STOP 状态或更高状态，并且当前线程未被中断，就中断当前线程。
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                    // 执行任务的run方法。
                        task.run();
                    } 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++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

这段代码描述了工作线程的主要执行逻辑，其中包括任务的获取、执行、异常处理、线程状态的检查以及线程的清理工作。

在这里插入图片描述

jakiechaipush

关注

19
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Java线程池底层原理

下面就来解释一下为什么上面不同的线程池执行速度会不同，对于newCachedThreadPool，它会根据需要创建很多线程，也会出现线程复用的情况所以它执行速度很快，然后newFixedThreadPool它只创建了10个线程去执行100个任务，速度会比newCachedThreadPool慢，最后是newSingleThreadExecutor它只有一个线程执行100个任务所以它是最慢的。这段代码描述了工作线程的主要执行逻辑，其中包括任务的获取、执行、异常处理、线程状态的检查以及线程的清理工作。
复制链接

扫一扫