多线程及并发编程之线程池一

最新推荐文章于 2024-04-27 16:09:57 发布

都要好好的O

最新推荐文章于 2024-04-27 16:09:57 发布

阅读量1.4k

点赞数 2

分类专栏：并发编程文章标签：并发编程多线程线程池

本文链接：https://blog.csdn.net/ming13849012515/article/details/123721451

版权

并发编程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

为什么使用线程池呢？

Java中的线程池是运用场景最多的并发框架，但思考下为什么要使用线程池呢？

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

但是如果想要合理的使用线程池必须呀要理解其原理,才能应用的得心应手；

线程池的实现原理

思考下：在使用线程池的情况下，当向线程池中提交一个任务后，线程池是如何处理这个任务的呢？看下图：

从图中可以看出，当提交一个新任务到线程池时，线程池的处理流程如下。

1）线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。

2）线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

3）线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

了解了线程池的原理，那么线程池是如何执行的呢？

线程池的真正实现类是 ThreadPoolExecutor(后文做详解)，那基于ThreadPoolExecutor 是如何实现线程池的执行过程呢？参考下图：

主线程通过execute()、submit()方法(思考两个方法的区别)来提交一个任务到线程池，然后经历1 2 3 4过程来实现线程的执行（是不是和线程池实现原理一样呢？），详细分析下：

ThreadPoolExecutor执行execute、submit()方法分下面4种情况。

1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。（这一步不太理解，欢迎大家解答）

2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。

3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要获取全局锁）。

4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用 RejectedExecutionHandler.rejectedExecution()方法。

ThreadPoolExecutor采取上述步骤的总体设计思路，是为了在执行execute()方法时，尽可能地避免获取全局锁（那将会是一个严重的可伸缩瓶颈）。在ThreadPoolExecutor完成预热之后（当前运行的线程数大于等于corePoolSize），几乎所有的execute()方法调用都是执行步骤2，而步骤2不需要获取全局锁。

源码分析：上面的流程分析让我们很直观地了解了线程池的工作原理，让我们再通过源代码来看看是如何实现的，线程池执行任务的方法如下。

public void execute(Runnable command) { 
    if (command == null) 
        throw new NullPointerException(); 
    // 如果线程数小于基本线程数，则创建线程并执行当前任务 
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { 
        // 如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中。 
        if (runState == RUNNING && workQueue.offer(command)) { 
            if (runState != RUNNING || poolSize == 0) 
                    ensureQueuedTaskHandled(command); 
        } 
        // 如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量， 
        // 则创建一个线程执行任务。 
        else if (!addIfUnderMaximumPoolSize(command)) 
            // 抛出RejectedExecutionException异常 
            reject(command); // is shutdown or saturated 
    } 
}

需要提一下的：线程池中执行任务的线程是工作线程；工作线程：线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务

后，还会循环获取工作队列里的任务来执行。我们可以从Worker类的run()方法里看到这点。

public void run() { 
    try {
        Runnable task = firstTask; 
        firstTask = null; 
        while (task != null || (task = getTask()) != null) { 
            runTask(task);
            task = null; 
        } 
    } finally { 
        workerDone(this); 
    } 
}

线程池的使用

线程池的创建

了解完了线程池的执行过程，我们来了解下创建ThreadPoolExecutor有哪些方法：其构造方法有如下4种：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), handler);
}
 
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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

从上述的构造方法中，我们可以得出几个创建线程池的重要参数 corePoolSize, maximumPoolSize, keepAliveTime, timeUnit,workQueue, threadFactory,rejectedExecutionHandler；为了创建合理的线程池，我们需要详细了解下以上参数的意义；

corePoolSize(必需)：线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize, 即使有其他空闲线程能够执行新来的任务, 也会继续创建线程；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行；如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。注意一点核心线程数一旦创建后，默认情况下，核心线程会一直存活不会随着任务的减少（小于核心线程数）而中断，会继续存活，等待新的任务加入到线程池，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
maximumPoolSize(必需)：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。注意：与核心线程不同的是，非核心线程会随着任务的减少的中断，也就是线程闲置时，超过keepAliveTime 指定值，将会被回收。
keepAliveTime(必需)：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
unit（必需）：指定 keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）TimeUnit.MINUTES（分）。
threadFactory(可选)：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设更有意义的名字。使用开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字，代码如下。

new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();

workQueue (必需)：用来保存等待被执行的任务的阻塞队列. 在JDK中提供了如下阻塞队列: 具体可以参考JUC 集合: BlockQueue详解

任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。

ArrayBlockingQueue: 基于数组结构的有界阻塞队列，按先进先出FIFO排序任务；
LinkedBlockingQuene: 基于链表结构的阻塞队列，按先进先出FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
SynchronousQuene: 一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；静态工厂方法Executors.newCachedThreadPool使用了这个队列
PriorityBlockingQuene: 具有优先级的无界阻塞队列；
LinkedBlockingQueue比ArrayBlockingQueue在插入删除节点性能方面更优，但是二者在put(), take()任务的时均需要加锁，
SynchronousQueue使用无锁算法，根据节点的状态判断执行，而不需要用到锁，其核心是Transfer.transfer().

LinkedBlockingQueue比ArrayBlockingQueue在插入删除节点性能方面更优，但是二者在put(), take()任务的时均需要加锁，

SynchronousQueue使用无锁算法，根据节点的状态判断执行，而不需要用到锁，其核心是Transfer.transfer().

rejectedExecutionHandler(可选)：拒绝策略。当达到最大线程数时需要执行的饱和策略。当队列和线程池都满了，说明线程池处于饱和状

态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。

在JDK 1.5中Java线程池框架提供了以下4种策略。

AbortPolicy：直接抛出异常。 (默认)
CallerRunsPolicy：只用调用者所在线程来运行任务。
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy：不处理，直接丢弃掉。

当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务。

上面介绍的是通过ThreadPoolExecutor 创建线程池的方法，也是推荐创建线程池的方式，这样有助于我们全面了解线程池。

Java中还有一个别的方式可以创建线程池，可以作为了解：从ThreadPoolExecutor的构造方法中有一个工具类：Executors，可以通过该工具类创建以下几种类型的线程池

newFixedThreadPool （固定大小的线程池）

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

线程池的线程数量达corePoolSize后，即使线程池没有可执行任务时，也不会释放线程。

FixedThreadPool的工作队列为无界队列 LinkedBlockingQueue(队列容量为Integer.MAX_VALUE), 这会导致以下问题:

线程池里的线程数量不超过corePoolSize,这导致了maximumPoolSize和keepAliveTime将会是个无用参数
由于使用了无界队列, 所以FixedThreadPool永远不会拒绝, 即饱和策略失效

newSingleThreadExecutor （单个线程的线程池）

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

初始化的线程池中只有一个线程，如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行。

由于使用了无界队列, 所以SingleThreadPool永远不会拒绝, 即饱和策略失效

newCachedThreadPool

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

线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；执行过程与前两种稍微不同:

主线程调用SynchronousQueue的offer()方法放入task, 倘若此时线程池中有空闲的线程尝试读取 SynchronousQueue的task, 即调用了SynchronousQueue的poll(), 那么主线程将该task交给空闲线程. 否则执行(2)
当线程池为空或者没有空闲的线程, 则创建新的线程执行任务.
执行完任务的线程倘若在60s内仍空闲, 则会被终止. 因此长时间空闲的CachedThreadPool不会持有任何线程资源.

ScheduledThreadPool 定时线程池 (之后详细说明)

上面说过了线程池的创建，接下来说下：

线程的提交

首先线程提交共有两种方式，上面讲述ThreadPoolExecutor 我们说过，

也就是：execute()、submit()方法;那么这两种方法有什么不同呢？

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。

通过以下代码可知execute()方法：输入的任务是一个Runnable类的实例。通过Runnable 接口的run方法可以明白，execute()方法没有返回值的原因；

threadsPool.execute(new Runnable() { 
    @Override 
    public void run() { 
        // TODO Auto-generated method stub 
    } 
});

submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个 future对象可以判断任务是否执行成功;注意下：

使用submit方法的话，任务类是必须实现Callable接口还是Callable和Runnable接口都可以呢？
- 都可以，但是想要拿到返回值的话只能用callable

并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，

而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

Future<Object> future = executor.submit(harReturnValuetask); 
try { 
    Object s = future.get(); 
}  catch (ExecutionException e) { 
    // 处理无法执行任务异常 
} finally { 
    // 关闭线程池 
    executor.shutdown(); 
}

了解了线程的提交，那么如何关闭线程池呢？

关闭线程池

关闭线程池：可以通过调用线程池的shutdown()或shutdownNow()方法来关闭线程池。

它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别:

shutdownNow():首先将线程池的状态设置成 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，

shutdown():只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

只要调用了这两个关闭方法中的任意一个，isShutdown()方法就会返回true。

当所有的任务都已关闭后，才表示线程池关闭成功，这时调用 isTerminaed()方法会返回true。

至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown()方法来关闭线程池，

如果任务不一定要执行完，则可以调用shutdownNow()方法。

注意：线程池的关闭要结合实际的场景来选择 shutdown()或shutdownNow() 方法；或者不做关闭处理也是可以的。

线程池的五种状态以及状态之间的切换

通过上面的讲述我们了解的线程池的创建线程的提交线程池的关闭。那么这里我们就有必要说下线程池的五种状态。（重点哦）

RUNNING = 1 COUNT_BITS; //高3位为111
SHUTDOWN = 0 COUNT_BITS; //高3位为000
STOP = 1 COUNT_BITS; //高3位为001
TIDYING = 2 COUNT_BITS; //高3位为010
TERMINATED = 3 COUNT_BITS; //高3位为011

1、RUNNING

(1) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。

(2) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！

2、 SHUTDOWN

(1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。

(2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING---->SHUTDOWN。

3、STOP

(1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。

(2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) ----> STOP。

4、TIDYING

(1) 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING 状态。

当线程池变为TIDYING状态时，会执行钩子函数 terminated()。

terminated()在 ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。

(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。

当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

5、TERMINATED

(1) 状态说明：线程池彻底终止，就变成TERMINATED状态。

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

进入TERMINATED的条件如下：

线程池不是RUNNING状态；
线程池状态不是TIDYING状态或TERMINATED状态；
如果线程池状态是SHUTDOWN并且workerQueue为空；
workerCount为0；
设置TIDYING状态成功。

华丽分割线到此可以算是：介绍完了线程池的原理和使用方法。下面还有很多呢。继续加油哦！下面留个小尾巴。。。。

线程池的体系架构

线程池的体系架构可以让我们更全面了解线程池，接下来根据类、接口的维度来聊聊线程池

都要好好的O

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
多线程及并发编程之线程池一

为什么使用线程池呢？Java中的线程池是运用场景最多的并发框架，但思考下为什么要使用线程池呢？（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是如果想要合理的使用线程池必须呀要理解其原理,才能应用的得心应手；线程池的实现原理思考.
复制链接

扫一扫