jdk自带线程池详解

其他 2018-06-08 20:07:35 阅读次数: 2

一、前言

在最近做的一个项目中，需要大量的使用到多线程和线程池，下面就Java自带的线程池和大家一起分享。

二、简介

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力，但频繁的创建线程的开销是很大的，那么如何来减少这部分的开销了，那么就要考虑使用线程池了。线程池就是一个线程的容器，每次只执行额定数量的线程，线程池就是用来管理这些额定数量的线程。

三、涉及线程池的类结构图


其中供我们使用的，主要是ThreadPoolExecutor类。

四、如何创建线程池

我们创建线程池一般有以下几种方法：

1、使用Executors工厂类

Executors主要提供了下面几种创建线程池的方法：


下面来看下使用示例：

1)newFixedThreadPool(固定大小的线程池)

[java] view plain copy
  1. public class FixedThreadPool {  
  2.     public static void main(String[] args) {  
  3.         ExecutorService pool = Executors.newFixedThreadPool(5);// 创建一个固定大小为5的线程池  
  4.         for (int i = 0; i < 10; i++) {  
  5.             pool.submit(new MyThread());  
  6.         }  
  7.         pool.shutdown();  
  8.     }  
  9. }  
[java] view plain copy
  1. public class MyThread extends Thread {  
  2.     @Override  
  3.     public void run() {  
  4.         System.out.println(Thread.currentThread().getName() + "正在执行。。。");  
  5.     }  
  6. }  

测试结果如下：

[java] view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-2正在执行。。。  
  3. pool-1-thread-3正在执行。。。  
  4. pool-1-thread-2正在执行。。。  
  5. pool-1-thread-3正在执行。。。  
  6. pool-1-thread-2正在执行。。。  
  7. pool-1-thread-2正在执行。。。  
  8. pool-1-thread-3正在执行。。。  
  9. pool-1-thread-5正在执行。。。  
  10. pool-1-thread-4正在执行。。。  

固定大小的线程池:每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程线。

2)newSingleThreadExecutor(单线程的线程池)

[java] view plain copy
  1. public class SingleThreadPool {  
  2.     public static void main(String[] args) {    
  3.         ExecutorService pool=Executors.newSingleThreadExecutor();//创建一个单线程池    
  4.         for(int i=0;i<100;i++){    
  5.             pool.submit(new MyThread());    
  6.         }    
  7.         pool.shutdown();    
  8.     }  
  9. }  

测试结果如下：

[java] view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-1正在执行。。。  
  3. pool-1-thread-1正在执行。。。  
  4. pool-1-thread-1正在执行。。。  
  5. pool-1-thread-1正在执行。。。  
  6. pool-1-thread-1正在执行。。。  
  7. pool-1-thread-1正在执行。。。  
  8. pool-1-thread-1正在执行。。。  
  9. pool-1-thread-1正在执行。。。  
  10. pool-1-thread-1正在执行。。。  

单线程的线程池:这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

3)newScheduledThreadPool

[java] view plain copy
  1. public class ScheduledThreadPool {  
  2.     public static void main(String[] args) {    
  3.         ScheduledExecutorService pool=Executors.newScheduledThreadPool(6);    
  4.         for(int i=0;i<10000;i++){    
  5.             pool.submit(new MyThread());    
  6.         }    
  7.             
  8.         pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);    
  9.         pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);    
  10.         pool.shutdown();    
  11.     }    
  12. }  

测试结果如下：

[java] view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-6正在执行。。。  
  3. pool-1-thread-5正在执行。。。  
  4. pool-1-thread-4正在执行。。。  
  5. pool-1-thread-2正在执行。。。  
  6. pool-1-thread-3正在执行。。。  
  7. pool-1-thread-4正在执行。。。  
  8. pool-1-thread-5正在执行。。。  
  9. pool-1-thread-6正在执行。。。  
  10. pool-1-thread-1正在执行。。。  
  11. …………此处会延时1S…………  
  12. pool-1-thread-4正在执行。。。  
  13. pool-1-thread-1正在执行。。。  
测试结果的最后两个线程都是在延时1S之后，才开始执行的。此线程池支持定时以及周期性执行任务的需求

4)newCachedThreadPool(可缓存的线程池)

[java] view plain copy
  1. public class CachedThreadPool {  
  2.     public static void main(String[] args) {    
  3.         ExecutorService pool=Executors.newCachedThreadPool();    
  4.         for(int i=0;i<100;i++){    
  5.             pool.submit(new MyThread());    
  6.         }    
  7.         pool.shutdown();    
  8.     }    
  9. }  

测试结果如下：

[java] view plain copy
  1. pool-1-thread-5正在执行。。。  
  2. pool-1-thread-7正在执行。。。  
  3. pool-1-thread-5正在执行。。。  
  4. pool-1-thread-16正在执行。。。  
  5. pool-1-thread-17正在执行。。。  
  6. pool-1-thread-16正在执行。。。  
  7. pool-1-thread-5正在执行。。。  
  8. pool-1-thread-7正在执行。。。  
  9. pool-1-thread-16正在执行。。。  
  10. pool-1-thread-18正在执行。。。  
  11. pool-1-thread-10正在执行。。。  
可缓存的线程池：如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（ 60 秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说 JVM ）能够创建的最大线程大小。

官方建议程序员使用较为方便的Executors工厂方法Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）、Executors.newFixedThreadPool(int)（固定大小线程池）Executors.newSingleThreadExecutor()（单个后台线程），这几种线程池均为大多数使用场景预定义了默认配置。

2、继承ThreadPoolExecutor类，并复写父类的构造方法。

在介绍这种方式之前，我们来分析下前面几个创建线程池的底层代码是怎样的？

[java] view plain copy
  1. public class Executors {  
  2.     public static ExecutorService newFixedThreadPool(int nThreads) {  
  3.         return new ThreadPoolExecutor(nThreads, nThreads,  
  4.                                       0L, TimeUnit.MILLISECONDS,  
  5.                                       new LinkedBlockingQueue<Runnable>());  
  6. }  
  7.   
  8.     public static ExecutorService newSingleThreadExecutor() {  
  9.         return new FinalizableDelegatedExecutorService  
  10.             (new ThreadPoolExecutor(1, 1,  
  11.                                     0L, TimeUnit.MILLISECONDS,  
  12.                                     new LinkedBlockingQueue<Runnable>()));  
  13.     }  
  14. }  

从Executors工厂类的底层代码可以看出，工厂类提供的创建线程池的方法，其实都是通过构造ThreadPoolExecutor来实现的。ThreadPoolExecutor构造方法代码如下：

[java] view plain copy
  1. public ThreadPoolExecutor(int corePoolSize,  
  2.                               int maximumPoolSize,  
  3.                               long keepAliveTime,  
  4.                               TimeUnit unit,  
  5.                               BlockingQueue<Runnable> workQueue,  
  6.                               ThreadFactory threadFactory,  
  7.                               RejectedExecutionHandler handler) {  
  8.         if (corePoolSize < 0 ||  
  9.             maximumPoolSize <= 0 ||  
  10.             maximumPoolSize < corePoolSize ||  
  11.             keepAliveTime < 0)  
  12.             throw new IllegalArgumentException();  
  13.         if (workQueue == null || threadFactory == null || handler == null)  
  14.             throw new NullPointerException();  
  15.         this.corePoolSize = corePoolSize;  
  16.         this.maximumPoolSize = maximumPoolSize;  
  17.         this.workQueue = workQueue;  
  18.         this.keepAliveTime = unit.toNanos(keepAliveTime);  
  19.         this.threadFactory = threadFactory;  
  20.         this.handler = handler;  
  21.     }  
那么接下来，我们就来谈谈这个 ThreadPoolExecutor 构造方法。在这个构造方法中，主要有以下几个参数：

corePoolSize--池中所保存的线程数，包括空闲线程。

maximumPoolSize--池中允许的最大线程数。

keepAliveTime--当线程数大于corePoolSize时，此为终止空闲线程等待新任务的最长时间。

Unit--keepAliveTime 参数的时间单位。

workQueue--执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。

threadFactory--执行程序创建新线程时使用的工厂。

Handler--由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

接下来，咋们来说下这几个参数之间的关系。当线程池刚创建的时候，线程池里面是没有任何线程的(注意，并不是线程池一创建，里面就创建了一定数量的线程)，当调用execute()方法添加一个任务时，线程池会做如下的判断：

1)如果当前正在运行的线程数量小于corePoolSize，那么立刻创建一个新的线程，执行这个任务。

2)如果当前正在运行的线程数量大于或等于corePoolSize，那么这个任务将会放入队列中。

3)如果线程池的队列已经满了，但是正在运行的线程数量小于maximumPoolSize，那么还是会创建新的线程，执行这个任务。

4)如果队列已经满了，且当前正在运行的线程数量大于或等于maximumPoolSize，那么线程池会根据拒绝执行策略来处理当前的任务。

5)当一个任务执行完后，线程会从队列中取下一个任务来执行，如果队列中没有需要执行的任务，那么这个线程就会处于空闲状态，如果超过了keepAliveTime存活时间，则这个线程会被线程池回收(注：回收线程是有条件的，如果当前运行的线程数量大于corePoolSize的话，这个线程就会被销毁，如果不大于corePoolSize，是不会销毁这个线程的，线程的数量必须保持在corePoolSize数量内).为什么不是线程一空闲就回收，而是需要等到超过keepAliveTime才进行线程的回收了，原因很简单：因为线程的创建和销毁消耗很大，更不能频繁的进行创建和销毁，当超过keepAliveTime后，发现确实用不到这个线程了，才会进行销毁。这其中unit表示keepAliveTime的时间单位，unit的定义如下：

[java] view plain copy
  1. public enum TimeUnit {  
  2.     NANOSECONDS {  
  3.         // keepAliveTime以纳秒为单位  
  4.     },  
  5.     MICROSECONDS {  
  6.        // keepAliveTime以微秒为单位  
  7.     },  
  8.     MILLISECONDS {  
  9.        // keepAliveTime以毫秒为单位  
  10.     },  
  11.     SECONDS {  
  12.         // keepAliveTime以秒为单位  
  13.     },  
  14.     MINUTES {  
  15.        // keepAliveTime以分钟为单位  
  16.     },  
  17.     HOURS {  
  18.        // keepAliveTime以小时为单位  
  19.     },  
  20.     DAYS {  
  21.         // keepAliveTime以天为单位  
  22.     };  

下面从源码来分析一下，对于上面的几种情况，主要涉及到的源码有以下几块：

[java] view plain copy
  1. private boolean addIfUnderCorePoolSize(Runnable firstTask) {  
  2.         Thread t = null;  
  3.         final ReentrantLock mainLock = this.mainLock;  
  4.         mainLock.lock();  
  5.         try {  
  6.             if (poolSize < corePoolSize && runState == RUNNING)  
  7.                 t = addThread(firstTask);  
  8.         } finally {  
  9.             mainLock.unlock();  
  10.         }  
  11.         if (t == null)  
  12.             return false;  
  13.         t.start();  
  14.         return true;  
  15. }  
  16.   
  17. 其实，这段代码很简单，主要描述的就是，如果当前的线程池小于corePoolSize的时候，是直接新建一个线程来处理任务。  
  18. private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {  
  19.         Thread t = null;  
  20.         final ReentrantLock mainLock = this.mainLock;  
  21.         mainLock.lock();  
  22.         try {  
  23.             if (poolSize < maximumPoolSize && runState == RUNNING)  
  24.                 t = addThread(firstTask);  
  25.         } finally {  
  26.             mainLock.unlock();  
  27.         }  
  28.         if (t == null)  
  29.             return false;  
  30.         t.start();  
  31.         return true;  
  32. }  
  33.   
  34. 上面这段代码描述的是，如果当前线程池的数量小于maximumPoolSize的时候，也会创建一个线程，来执行任务  
五、线程池的队列

线程池的队列，总的来说有3种：

直接提交：工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

无界队列：使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

有界队列：当使用有限的 maximumPoolSizes时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

下面就来说下线程池的队列，类结构图如下：


1)SynchronousQueue

该队列对应的就是上面所说的直接提交，首先SynchronousQueue是无界的，也就是说他存数任务的能力是没有限制的，但是由于该Queue本身的特性，在某次添加元素后必须等待其他线程取走后才能继续添加。

2)LinkedBlockingQueue

该队列对应的就是上面的无界队列。

3)ArrayBlockingQueue

该队列对应的就是上面的有界队列。ArrayBlockingQueue有以下3中构造方法：

[java] view plain copy
  1. public ArrayBlockingQueue(int capacity) {  
  2.         this(capacity, false);  
  3.     }  
  4.   
  5.       
  6.     public ArrayBlockingQueue(int capacity, boolean fair) {  
  7.         if (capacity <= 0)  
  8.             throw new IllegalArgumentException();  
  9.         this.items = (E[]) new Object[capacity];  
  10.         lock = new ReentrantLock(fair);  
  11.         notEmpty = lock.newCondition();  
  12.         notFull =  lock.newCondition();  
  13. }  
  14.   
  15.     public ArrayBlockingQueue(int capacity, boolean fair,  
  16.                               Collection<? extends E> c) {  
  17.         this(capacity, fair);  
  18.         if (capacity < c.size())  
  19.             throw new IllegalArgumentException();  
  20.   
  21.         for (Iterator<? extends E> it = c.iterator(); it.hasNext();)  
  22.             add(it.next());  
  23.     }  

下面我们重点来说下这个fair，fair表示队列访问线程的竞争策略，当为true的时候，任务插入队列遵从FIFO的规则，如果为false，则可以“插队”。举个例子，假如现在有很多任务在排队，这个时候正好一个线程执行完了任务，同时又新来了一个任务，如果为false的话，这个任务不用在队列中排队，可以直接插队，然后执行。如下图所示：

六、线程池的拒绝执行策略

当线程的数量达到最大值时，这个时候，任务还在不断的来，这个时候，就只好拒绝接受任务了。

ThreadPoolExecutor 允许自定义当添加任务失败后的执行策略。你可以调用线程池的 setRejectedExecutionHandler() 方法，用自定义的RejectedExecutionHandler 对象替换现有的策略，ThreadPoolExecutor提供的默认的处理策略是直接丢弃，同时抛异常信息，ThreadPoolExecutor 提供 4 个现有的策略，分别是：
ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常，源码如下：

[java] view plain copy
  1. public static class AbortPolicy implements RejectedExecutionHandler {  
  2.         /** 
  3.          * Creates an <tt>AbortPolicy</tt>. 
  4.          */  
  5.         public AbortPolicy() { }  
  6.   
  7.         /** 
  8.          * Always throws RejectedExecutionException. 
  9.          * @param r the runnable task requested to be executed 
  10.          * @param e the executor attempting to execute this task 
  11.          * @throws RejectedExecutionException always. 
  12.          */  
  13.         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
  14.             throw new RejectedExecutionException(); //抛异常  
  15.         }  
  16.     }  

 ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作，源码如下：

[java] view plain copy
  1. public static class DiscardPolicy implements RejectedExecutionHandler {  
  2.         /** 
  3.          * Creates a <tt>DiscardPolicy</tt>. 
  4.          */  
  5.         public DiscardPolicy() { }  
  6.   
  7.         /** 
  8.          * Does nothing, which has the effect of discarding task r. 
  9.          * @param r the runnable task requested to be executed 
  10.          * @param e the executor attempting to execute this task 
  11.          */  
  12.         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
  13.         } // 直接拒绝，但不做任何操作  
  14.     }  

 ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务，源码如下：

[java] view plain copy
  1. public static class CallerRunsPolicy implements RejectedExecutionHandler {  
  2.         /** 
  3.          * Creates a <tt>CallerRunsPolicy</tt>. 
  4.          */  
  5.         public CallerRunsPolicy() { }  
  6.   
  7.         /** 
  8.          * Executes task r in the caller's thread, unless the executor 
  9.          * has been shut down, in which case the task is discarded. 
  10.          * @param r the runnable task requested to be executed 
  11.          * @param e the executor attempting to execute this task 
  12.          */  
  13.         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
  14.             if (!e.isShutdown()) {  
  15.                 r.run(); // 直接执行任务  
  16.             }  
  17.         }  
  18.     }  

 ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。源码如下：

[java] view plain copy
  1. public static class DiscardOldestPolicy implements RejectedExecutionHandler {  
  2.         /** 
  3.          * Creates a <tt>DiscardOldestPolicy</tt> for the given executor. 
  4.          */  
  5.         public DiscardOldestPolicy() { }  
  6.   
  7.         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
  8.             if (!e.isShutdown()) {  
  9.                 e.getQueue().poll(); // 丢弃队列中的第一个任务  
  10.                 e.execute(r); // 执行新任务  
  11.             }  
  12.         }  
  13. }  
  14.   
  15. 当任务源源不断到来的时候，会从Queue中poll一个任务出来，然后执行新的任务

猜你喜欢

转载自blog.csdn.net/sqiucheng/article/details/75577942
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022