Java并发系列之7 深入理解线程池ThreadPoolExecutor

简介: Java并发系列之7 深入理解线程池ThreadPoolExecutor

1. 初识线程池


线程池解决了如下两个问题


当执行大量的异步任务时,线程池可以减少每个任务的调用切换开销从而提高应用性能

对执行的线程,和要被执行的任务,提供了管理的方法


此外每个线程池还维护了一些基本统计信息,比如已完成任务的数量


2. ThreadPoolExecutor的简单使用


我们创建一个线程池对象ThreadPoolExecutor,让线程池执行10个打印任务,输出当前任务名称以及线程的名称

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,5,0L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(10));
        for(int i=0;i<10;i++){
            final int num = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.MILLISECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("execute task "+num+" in "+Thread.currentThread().getName());
                }
            });
        }
    }
}

代码还是蛮简单的。首先创建一个ThreadPoolExecutor对象,然后调用ThreadPoolExecutor.execute(Runnable runnable)方法。输出结果如下。我们可以观察到线程池启动了两个线程pool-1-thread-1和pool-1-thread-2来执行任务。那么这里提两个问题


该线程池最多能启动5个线程,为什么线程池只启动了2个线程来执行任务?

如果把for循环次数由10改成100,线程池会启动几个线程呢?


如果你还不是很有把握回答这两个问题那么请接着看下文分析吧。

execute task 0 in pool-1-thread-1
execute task 1 in pool-1-thread-2
execute task 2 in pool-1-thread-1
execute task 3 in pool-1-thread-2
execute task 5 in pool-1-thread-2
execute task 4 in pool-1-thread-1
execute task 6 in pool-1-thread-2
execute task 7 in pool-1-thread-1
execute task 8 in pool-1-thread-2
execute task 9 in pool-1-thread-1

3. ThreadPoolExecutor的成员变量和构造函数

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

线程池中的线程被逻辑分为两类(核心线程和非核心线程)。核心线程如果被启动了,一般情况下是会一直活着的(除非allowCoreThreadTimeOut被设置成true),非核心线程在keepAlivTime时间范围内,如果没有任务执行会被系统中断回收掉。


那么核心线程是在什么时候被创建并启动的呢?非核心线程又是在什么时候被创建并启动的呢?(稍安勿躁,后面会给出答案)


workQueue是指任务的集合。我们可以把ThreadPoolExecutor简单的认为它只有两个比较重要的属性 线程的集合和任务的集合。

private final HashSet<Worker> workers = new HashSet<>();
private final BlockingQueue<Runnable> workQueue;

workers对象正是线程的集合,后面我们会对Worker对象做一个详细的讲解

workQueue是一个阻塞队列。阻塞队列的概念就是如果队列满了那么put操作会阻塞,如果队列为空那么take操作会阻塞。

线程池的工作原理我们可以简单地认为是往workQueue里面put任务,系统会合理的调度workers中的线程来处理workQueue中的任务。


下面我们来对构造函数的各个参数做一个详细的介绍


corePoolSize:核心线程个数,当新的任务通过execute(java.lang.Runnable)方法提交到线程池中,如果线程池的线程个数小于corePoolSize设定的值时,不管线程池中的线程是否空闲,都会新建线程来处理该任务

maximumPoolSize:线程池最多允许的线程数。如果线程池中的线程数量大于等于corePoolSize而且小于等于maximumPoolSize,如果此时workQueue已满,则会创建新的线程来处理任务(如果线程数等于maximumPoolSize则会执行相应的拒绝策略),反之如果workQueue未满,则将该任务put到workQueue中。

keepAliveTime:允许线程空闲的时间,如果空闲时间超过,而且线程池中的线程数比corePoolSize数量多,则会中断和回收空闲线程

unit:keepAliveTime的时间单位,秒或者毫秒等

workQueue:工作队列可以用来交付和保存提交到线程池中的工作任务,它和corePoolSize maximumPoolSize相互作用


处理任务的流程如下


如果线程池中的线程数量小于corePoolSize,线程池将新建新的线程处理该任务,而不是将任务入队列

如果线程池中的线程数量大于等于corePoolSize,线程池将优先选择将任务入队列

如果入队列失败(队列已满),将创建新的线程处理任务,除非线程超过了maximumPoolSize,任务将被拒绝


三种不同的入队策略


直接交付,使用 SynchronousQueue直接交付任务,而不是把任务保存在队列中。

无界的队列,比如LinkedBlockingQueue,用无界队列构建的线程池,线程数永远不会超过corePoolSize

有界的队列,比如ArrayBlockingQueue,这种情况比较复杂,线程池同时受corePoolSize,maximumPoolSize,workQueue大小约束

threadFactory:主要是给线程池中的线程命名,以便查找问题

handler:线程池无法处理任务时的拒绝策略


4. execute(java.lang.Runnable)方法

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        //1 如果线程池中的线程数小于corePoolSize,新建线程处理command
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //2 如果线程池中的线程数量大于等于corePoolSize,将任务入队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //3 如果任务入队列失败,创建非核心线程处理任务
        else if (!addWorker(command, false))
            reject(command);//4.如果创建非核心线程失败,拒绝该任务
    }

如果线程池中的线程数小于corePoolSize,新建线程处理command

如果线程池中的线程数量大于等于corePoolSize,将任务入队列

如果任务入队列失败,创建非核心线程处理任务

如果创建非核心线程失败,拒绝该任务


5.Worker类(工作线程类)

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        private static final long serialVersionUID = 6138294804551838833L;
        /** Thread this worker is running in.  Null if factory fails. */
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;
        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        /** Delegates main run loop to outer runWorker. */
        public void run() {
            runWorker(this);
        }
        final void runWorker(Worker w) {
            Thread wt = Thread.currentThread();
            Runnable task = w.firstTask;
            w.firstTask = null;
            w.unlock(); // allow interrupts
            boolean completedAbruptly = true;
            try {
                while (task != null || (task = getTask()) != null) {
                    w.lock();
                    // If pool is stopping, ensure thread is interrupted;
                    // if not, ensure thread is not interrupted.  This
                    // requires a recheck in second case to deal with
                    // shutdownNow race while clearing interrupt
                    if ((runStateAtLeast(ctl.get(), STOP) ||
                    (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                        !wt.isInterrupted())
                        wt.interrupt();
                    try {
                      beforeExecute(wt, task);
                     Throwable thrown = null;
                     try {
                         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);
            }
    }
    }

Worker实现了Runnable接口,构造函数中this.thread = getThreadFactory().newThread(this),启动线程将执行run方法


Worker是AbstractQueuedSynchronizer的子类,说明了Worker本身是一把锁。如何判断工作线程是否空闲?就是通过work.tryLock()来判断不信可以看下interruptIdleWorkers(boolean onlyOne)方法,该方法的功能是中断空闲的工作线程

private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                //如果w.tryLock()返回true表示该工作线程处于空闲状态
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

我们来看下w.lock()调用的地方。在runWorker(Worker worker)方法中,在获取到任务去处理时,会调用w.lock()

final void runWorker(Worker w) {
            Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
        //从任务队列中获取任务,可能会阻塞,因为BlockingQueue是阻塞队列
            while (task != null || (task = getTask()) != null) {
                //如果获取到了任务去执行,上锁
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        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);
        }
    }

6. 工作线程什么时候启动的呢


在讲execute(Runnable runnable)的方法的时候,创建工作线程是通过addWorker(Runnable firstTask, boolean core)方法实现的

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            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))
                    //如果线程数超过了限制直接返回false
                    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 {
            //创建工作线程
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    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();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    //启动工作线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
  1. 判断线程池是否满足条件,如果不满足返回false
  2. 创建Worker对象,并启动工作线程


7. keepAliveTime功能是如何实现的


如何实现在keepAliveTime时间内空闲,中断线程的呢,答案在getTask()中

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            //1.如果调用了shutDownNow返回null
            //2.如果调用了shutDown而且workQueue没有任务返回null
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            //如果允许杀死空闲的核心线程,或者线程数超过corePoolSize
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
            //如果指定时间内获取不到任务,返回null,线程将会结束
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

1.判断是否需要杀死空闲的线程


允许杀死核心线程 返回true


不允许杀死核心线程 判断线程数是否大于corePoolSize


2.通过workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)方法获取任务,如果超时,返回null


3.runWorker中getTask返回null,跳出循环,调用processWorkerExit(w, completedAbruptly)

8. shutdown和shutdownNow的区别


shutdown方法调用后,不会处理新的任务,但是会处理已经进入队列的任务


shutdownNow方法调用后,不会处理新的任务,而且不会处理已经进入队列的任务,而且会停止所有的工作线程


相关文章
|
5天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
25 9
|
8天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
5天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
8天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
22 3
|
7天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
8天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
20 1
|
8天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
6月前
|
Java 调度
Java并发编程:深入理解线程池的原理与实践
【4月更文挑战第6天】本文将深入探讨Java并发编程中的重要概念——线程池。我们将从线程池的基本原理入手,逐步解析其工作过程,以及如何在实际开发中合理使用线程池以提高程序性能。同时,我们还将关注线程池的一些高级特性,如自定义线程工厂、拒绝策略等,以帮助读者更好地掌握线程池的使用技巧。
|
3月前
|
安全 Java 数据库
一天十道Java面试题----第四天(线程池复用的原理------>spring事务的实现方式原理以及隔离级别)
这篇文章是关于Java面试题的笔记,涵盖了线程池复用原理、Spring框架基础、AOP和IOC概念、Bean生命周期和作用域、单例Bean的线程安全性、Spring中使用的设计模式、以及Spring事务的实现方式和隔离级别等知识点。
|
2月前
|
存储 缓存 Java
JAVA并发编程系列(11)线程池底层原理架构剖析
本文详细解析了Java线程池的核心参数及其意义,包括核心线程数量(corePoolSize)、最大线程数量(maximumPoolSize)、线程空闲时间(keepAliveTime)、任务存储队列(workQueue)、线程工厂(threadFactory)及拒绝策略(handler)。此外,还介绍了四种常见的线程池:可缓存线程池(newCachedThreadPool)、定时调度线程池(newScheduledThreadPool)、单线程池(newSingleThreadExecutor)及固定长度线程池(newFixedThreadPool)。