Java线程池详解

最新推荐文章于 2024-05-08 16:47:16 发布

能先森

最新推荐文章于 2024-05-08 16:47:16 发布

阅读量474

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/qq_41144667/article/details/103835945

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

大千世界，茫茫人海，相识就是一种缘分。若此篇文章对您有帮助，点个赞或点个关注呗！

引言

近期项目开发中，用到了线程池技术点，仅以此博客加深对线程池的理解，便于后期开发能够合理使用线程池，最大限度的提高系统的性能。参考了好几个博主的相关文章，相关技术点总结的特别详细，一边理解，一边总结记录，与大家分享！不足之处，欢迎指点！

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。
线程池（英语：thread pool）： 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。例如，线程数一般取cpu数量+2比较合适，线程数过多会导致额外的线程切换开销。

一、线程池的好处

降低资源消耗------通过已有的线程来降低创建和销毁线程带来的消耗；
提高响应的速度------不需要等待线程创建就可以立即执行任务；
提高线程的可管理性------使用线程池可以对线程进行统一的分配，优化和监控；

二、Executor接口
在这里插入图片描述
由上图可知，ThreadPoolExecutor是线程池的真正实现，通过构造方法的一些列参数，来构成不同配置的线程池

Executor两级调度模式：

在HotSpot虚拟机中，Java中的线程将会被一一映射为操作系统的线程在Java虚拟机层面，用户将多个任务提交给Executor框架,Executor负责分配线程执行它们；在操作系统层面，操作系统再将这些线程分配给处理器执行；
Executor结构
Executor框架中的所有类可以分成三类：
任务： 任务有两种类型：Runnable和Callable。（两者区别，文章末尾有详解）
任务执行器：
Executor框架最核心的接口是Executor，它表示任务的执行器。
Executor的子接口为ExecutorService。
ExecutorService有两大实现类：ThreadPoolExecutor和ScheduledThreadPoolExecutor。
执行结果： Future接口表示异步的执行结果，它的实现类为FutureTask。

三、Executors 类：
Java 5（java.util.concurrent）引用Executors 工具类来得到 Executor 接口的具体对象。 Executors 提供了以下一些 static 的方法，主要罗列一下4种我们常用的方法：
1、newFixedThreadPool(int nThreads)------定长线程池
可重用的固定线程数量的线程池，以共享无界队列方式来运行
源码剖析：

/**
  *keepAliveTime为0，意味着一旦有多余的空闲线程，就会被立即停止掉；但这里keepAliveTime无效；
  *阻塞队列采用了LinkedBlockingQueue，它是一个无界队列；
  *由于阻塞队列是一个无界队列，因此永远不可能拒绝任务；
  *由于采用了无界队列，实际线程数量将永远维持在nThreads，因此maximumPoolSize和keepAliveTime将无效。
  */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

在这里插入图片描述
注意： 创建一个固定大小的线程池。每次提交一个任务就会创建一个线程，直到创建的线程数量达到线程池的最大nThreads。线程池的大小一旦达到最大值就会保持不变。如果在所有线程都处于活动状态时，这时再有其他任务提交，他们将等待队列中直到有空闲的线程可用。如果任何线程由于执行过程中的故障而终止，将会有一个新线程将取代这个线程执行后续任务。
示例如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author:bnl
 * @date 2020-1-4 18:33
 **/
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建线程池，nThreads为3
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //创建模拟执行的任务
        for (int i = 0; i < 5; i++) {
            final int taskID = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 5; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        //任务执行结束后打印
                        System.out.println(Thread.currentThread().getName()+"====="+"第" + taskID + "个任务的第" + i + "次执行");
                    }
                }
            });
        }
        executorService.shutdown();
    }
}

执行结果：
在这里插入图片描述
结果总结： 上述代码中，创建固定大小的线程池，容量为3，循环执行4个任务。由执行结果得知，前3个任务执行完毕后，然后空闲下来的线程去执行第4个任务。在FixedThreadPool中，有一个固定大小的池，如果当前执行的任务数量超过线程池设定的容量，就会将当前需执行的任务进入阻塞队列，直到有空余线程才去执行阻塞队列中的任务。而当需执行的线程数量小于线程池容量，空闲的线程不会被销毁，而是处于随机待命状态！

2、newSingleThreadExecutor()------单一线程池
单一线程池，只含有一个线程的线程池。若当前线程在执行任务的过程中突然中断，则会创建一个新的线程取替代它从而继续执行任务！
源码剖析：

/**
  *它只会创建一条工作线程处理任务；
  *采用的阻塞队列为LinkedBlockingQueue；
  */
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

在这里插入图片描述
示例如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author:bnl
 * @date 2020-1-4 18:33
 **/
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建单一线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //创建模拟执行的任务
        for (int i = 0; i < 3; i++) {
            final int taskID = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 3; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        //任务执行结束后打印
                        System.out.println(Thread.currentThread().getName()+"====="+"第" + taskID + "个任务的第" + i + "次执行");
                    }
                }
            });
        }
        executorService.shutdown();
    }
}

执行结果：
在这里插入图片描述
结果总结： 模拟执行的3个任务一次执行，newSingleThreadExecutor为单一线程，该线程=会保证需执行的任务执行完成。若当前线程意外终止，则会创建一个新的线程继续执行当前任务，与我们直接创建或者newFixedThreadPool(1)不同，切勿混淆！

3、newCachedThreadPool()------可缓存线程池
可以无限扩大的线程池,对于短期异步执行的任务，该线程池可提高程序的性能。
源码剖析：

/**
 *可以无限扩大的线程池；
 *比较适合处理执行时间比较小的任务；
 *corePoolSize为0，maximumPoolSize为无限大，意味着线程数量可以无限大；
 *keepAliveTime为60S，意味着线程空闲时间超过60S就会被杀死；
 *采用SynchronousQueue装等待的任务，这个阻塞队列没有存储空间，这意味着只要有请求到来，就必须要找到一条工作线程处理他，如果当
 *前没有空闲的线程，那么就会再创建一条新的线程。
 */
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

在这里插入图片描述
示例如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author:bnl
 * @date 2020-1-4 18:33
 **/
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建可缓存线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //创建模拟执行的任务
        for (int i = 0; i < 4; i++) {
            final int taskID = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 4; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        //任务执行结束后打印
                        System.out.println(Thread.currentThread().getName()+"====="+"第" + taskID + "个任务的第" + i + "次执行");
                    }
                }
            });
        }
        executorService.shutdown();
    }
}

执行结果：
在这里插入图片描述
结果总结： 创建4个需要执行得任务，newCachedThreadPool会创建一个缓存区，将初始化的线程缓存起来，如果有线程可用，就使用已缓存并且空闲的线程，如果没有科使用的线程，就会创建新的线程。剔除缓存中空闲时间已达60s的线程！

4、newScheduledThreadPool ()------可调度的线程池
创建一个可根据设定的延迟时间执行或定期执行的线程池！
源码剖析：

/**
 *该线程池接收SchduledFutureTask类型的任务，有两种提交任务的方式：scheduledAtFixedRate与scheduledWithFixedDelay
 *SchduledFutureTask接收的参数：1、time：任务开始的时间 2、sequenceNumber：任务的序号  3、period：任务执行的时间间隔
 *采用DelayQueue存储等待的任务
 *DelayQueue内部封装了一个PriorityQueue，它会根据time的先后时间排序，若time相同则根据sequenceNumber排序；
 *DelayQueue也是一个无界队列；
 *工作线程的执行过程：工作线程会从DelayQueue取已经到期的任务去执行，执行结束后重新设置任务的到期时间，再次放回DelayQueue
 */
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

在这里插入图片描述
示例如下：
DateUtils时间工具类

import com.bnl.sync.core.util.DateUtils;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author:bnl
 * @date 2020-1-4 18:33
 **/
public class ThreadPoolDemo {
    public static void main(String[] args) {
        System.out.println("当前开始时间"+DateUtils.getNow());
        //创建可调度的线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        //创建模拟执行的线程
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(DateUtils.getNow()+"=========="+"schedule");
            }
        }, 5000, TimeUnit.MILLISECONDS);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(DateUtils.getNow()+"==========="+"scheduleAtFixedRate");
            }
        },5000,3000,TimeUnit.MILLISECONDS);
    }
}

执行结果：
在这里插入图片描述
结果总结： 定时执行设定的任务
四、 线程池的处理流程：

一个线程从被提交（submit）到执行共经历以下流程：

线程池判断核心线程池里是的线程是否都在执行任务，如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下一个流程
线程池判断工作队列是否已满。如果工作队列没有满，则将新提交的任务储存在这个工作队列里。如果工作队列满了，则进入下一个流程。
线程池判断其内部线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已满了，则交给饱和策略来处理这个任务。

线程池在执行execute方法时,主要有以下四种情况：
在这里插入图片描述

如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（需要获得全局锁）
如果运行的线程等于或多于corePoolSize ,则将任务加入BlockingQueue
如果无法将任务加入BlockingQueue(队列已满)，则创建新的线程来处理任务（需要获得全局锁）
如果创建新线程将使当前运行的线程超出maxiumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。
ThreeadPoolExecutor

//五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)
 
//六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)
 
//六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)
 
//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

参数解释

int corePoolSize：该线程池中核心线程数最大值

核心线程： 线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。
如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉。
int maximumPoolSize：该线程池中线程总数最大值
线程总数 = 核心线程数 + 非核心线程数。
long keepAliveTime：该线程池中非核心线程闲置超时时长
一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉，如果设置allowCoreThreadTimeOut = true，则会作用于核心线程。
BlockingQueue workQueue： 该线程池中的任务队列：维护着等待执行的Runnable对象
当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务。
常用的workQueue类型：
SynchronousQueue： 这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大。
LinkedBlockingQueue： 这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize。
ArrayBlockingQueue： 可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误。
DelayQueue： 队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务。
ThreadFactory threadFactory： 创建线程的方式，这是一个接口，你new他的时候需要实现他的Thread newThread(Runnable r)方法。
RejectedExecutionHandler handler： 当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理;jdk1.5提供了四种饱和策略：
AbortPolicy： 默认。直接抛异常。
CallerRunsPolicy： 只用调用者所在的线程执行任务,重试添加当前的任务，它会自动重复调用execute()方法
DiscardOldestPolicy： 丢弃任务队列中最久的任务。
DiscardPolicy： 丢弃当前任务。

提交任务
可以向ThreadPoolExecutor提交两种任务：Callable和Runnable。

Callable
该类任务有返回结果，可以抛出异常。
通过submit函数提交，返回Future对象。
可通过get获取执行结果。
Runnable
该类任务只执行，无法获取返回结果，并在执行过程中无法抛异常。
通过execute提交。

关闭线程池
关闭线程池有两种方式：shutdown和shutdownNow，关闭时，会遍历所有的线程，调用它们的interrupt函数中断线程。但这两种方式对于正在执行的线程处理方式不同。

shutdown()
仅停止阻塞队列中等待的线程，那些正在执行的线程就会让他们执行结束。
shutdownNow()
不仅会停止阻塞队列中的线程，而且会停止正在执行的线程。

设置合理的线程池大小
任务一般可分为：CPU密集型、IO密集型、混合型，对于不同类型的任务需要分配不同大小的线程池。

CPU密集型任务
尽量使用较小的线程池，一般为CPU核心数+1。
因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，只能增加上下文切换的次数，因此会带来额外的开销。
IO密集型任务
可以使用稍大的线程池，一般为2*CPU核心数。
IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候去处理别的任务，充分利用CPU时间。
混合型任务
可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。
只要分完之后两个任务的执行时间相差不大，那么就会比串行执行来的高效。
因为如果划分之后两个任务执行时间相差甚远，那么先执行完的任务就要等后执行完的任务，最终的时间仍然取决于后执行完的任务，而且还要加上任务拆分与合并的开销，得不偿失。

能先森

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java线程池详解

引言线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅...
复制链接

扫一扫