JAVA进阶----ThreadPoolExecutor机制                

博客分类:JAVA进阶java-多线程框架

javaExecutors并发线程池ThreadPoolExecutor 

               

ThreadPoolExecutor机制
一、概述
1、ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现,以内部线程池的形式对外提供管理任务执行,线程调度,线程池管理等等服务;
2、Executors方法提供的线程服务,都是通过参数设置来实现不同的线程池机制。
3、先来了解其线程池管理的机制,有助于正确使用,避免错误使用导致严重故障。同时可以根据自己的需求实现自己的线程池


二、核心构造方法讲解
下面是ThreadPoolExecutor最核心的构造方法

Java代码  收藏代码

  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.     }  


构造方法参数讲解

参数名作用
corePoolSize核心线程池大小
maximumPoolSize最大线程池大小
keepAliveTime线程池中超过corePoolSize数目的空闲线程最大存活时间;可以allowCoreThreadTimeOut(true)使得核心线程有效时间
TimeUnitkeepAliveTime时间单位
workQueue阻塞任务队列
threadFactory新建线程工厂
RejectedExecutionHandler当提交任务数超过maxmumPoolSize+workQueue之和时,任务会交给RejectedExecutionHandler来处理



重点讲解:
其中比较容易让人误解的是:corePoolSize,maximumPoolSize,workQueue之间关系。

1.当线程池小于corePoolSize时,新提交任务将创建一个新线程执行任务,即使此时线程池中存在空闲线程。
2.当线程池达到corePoolSize时,新提交任务将被放入workQueue中,等待线程池中任务调度执行
3.当workQueue已满,且maximumPoolSize>corePoolSize时,新提交任务会创建新线程执行任务
4.当提交任务数超过maximumPoolSize时,新提交任务由RejectedExecutionHandler处理
5.当线程池中超过corePoolSize线程,空闲时间达到keepAliveTime时,关闭空闲线程
6.当设置allowCoreThreadTimeOut(true)时,线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭


线程管理机制图示:
92ad4409-2ab4-388b-9fb1-9fc4e0d832cd.jpg

三、Executors提供的线程池配置方案

1、构造一个固定线程数目的线程池,配置的 corePoolSize与maximumPoolSize大小相同,同时使用了一个***LinkedBlockingQueue存放阻塞任务,因此多余 的任务将存在再阻塞队列,不会由RejectedExecutionHandler处理

Java代码  收藏代码

  1. public static ExecutorService newFixedThreadPool(int nThreads) {  

  2.         return new ThreadPoolExecutor(nThreads, nThreads,  

  3.                                       0L, TimeUnit.MILLISECONDS,  

  4.                                       new LinkedBlockingQueue<Runnable>());  

  5.     }  


2、构造一个缓冲功能的线程池,配置 corePoolSize=0,maximumPoolSize=Integer.MAX_VALUE,keepAliveTime=60s,以及一个无 容量的阻塞队列 SynchronousQueue,因此任务提交之后,将会创建新的线程执行;线程空闲超过60s将会销毁

Java代码  收藏代码

  1. public static ExecutorService newCachedThreadPool() {  

  2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  

  3.                                       60L, TimeUnit.SECONDS,  

  4.                                       new SynchronousQueue<Runnable>());  

  5.     }  


3、构造一个只支持一个线程的线程池,配置corePoolSize=maximumPoolSize=1,***阻塞队列LinkedBlockingQueue;保证任务由一个线程串行执行

Java代码  收藏代码

  1. public static ExecutorService newSingleThreadExecutor() {  

  2.         return new FinalizableDelegatedExecutorService  

  3.             (new ThreadPoolExecutor(11,  

  4.                                     0L, TimeUnit.MILLISECONDS,  

  5.                                     new LinkedBlockingQueue<Runnable>()));  

  6.     }  


4、构造有定时功能的线程池,配置corePoolSize, ***延迟阻塞队列DelayedWorkQueue;有意思的是:maximumPoolSize=Integer.MAX_VALUE,由于 DelayedWorkQueue是***队列,所以这个值是没有意义的

Java代码  收藏代码

  1. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  

  2.         return new ScheduledThreadPoolExecutor(corePoolSize);  

  3.     }  

  4.   

  5. public static ScheduledExecutorService newScheduledThreadPool(  

  6.             int corePoolSize, ThreadFactory threadFactory) {  

  7.         return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);  

  8.     }  

  9.   

  10. public ScheduledThreadPoolExecutor(int corePoolSize,  

  11.                              ThreadFactory threadFactory) {  

  12.         super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,  

  13.               new DelayedWorkQueue(), threadFactory);  

  14.     }  



四、定制属于自己的线程池

Java代码  收藏代码

  1. import java.util.concurrent.ArrayBlockingQueue;  

  2. import java.util.concurrent.ExecutorService;  

  3. import java.util.concurrent.RejectedExecutionHandler;  

  4. import java.util.concurrent.ThreadFactory;  

  5. import java.util.concurrent.ThreadPoolExecutor;  

  6. import java.util.concurrent.TimeUnit;  

  7. import java.util.concurrent.atomic.AtomicInteger;  

  8.   

  9.   

  10. public class CustomThreadPoolExecutor {  

  11.   

  12.       

  13.     private ThreadPoolExecutor pool = null;  

  14.       

  15.       

  16.     /** 

  17.      * 线程池初始化方法 

  18.      *  

  19.      * corePoolSize 核心线程池大小----10 

  20.      * maximumPoolSize 最大线程池大小----30 

  21.      * keepAliveTime 线程池中超过corePoolSize数目的空闲线程最大存活时间----30+单位TimeUnit 

  22.      * TimeUnit keepAliveTime时间单位----TimeUnit.MINUTES 

  23.      * workQueue 阻塞队列----new ArrayBlockingQueue<Runnable>(10)====10容量的阻塞队列 

  24.      * threadFactory 新建线程工厂----new CustomThreadFactory()====定制的线程工厂 

  25.      * rejectedExecutionHandler 当提交任务数超过maxmumPoolSize+workQueue之和时, 

  26.      *                          即当提交第41个任务时(前面线程都没有执行完,此测试方法中用sleep(100)), 

  27.      *                                任务会交给RejectedExecutionHandler来处理 

  28.      */  

  29.     public void init() {  

  30.         pool = new ThreadPoolExecutor(  

  31.                 10,  

  32.                 30,  

  33.                 30,  

  34.                 TimeUnit.MINUTES,  

  35.                 new ArrayBlockingQueue<Runnable>(10),  

  36.                 new CustomThreadFactory(),  

  37.                 new CustomRejectedExecutionHandler());  

  38.     }  

  39.   

  40.       

  41.     public void destory() {  

  42.         if(pool != null) {  

  43.             pool.shutdownNow();  

  44.         }  

  45.     }  

  46.       

  47.       

  48.     public ExecutorService getCustomThreadPoolExecutor() {  

  49.         return this.pool;  

  50.     }  

  51.       

  52.     private class CustomThreadFactory implements ThreadFactory {  

  53.   

  54.         private AtomicInteger count = new AtomicInteger(0);  

  55.           

  56.         @Override  

  57.         public Thread newThread(Runnable r) {  

  58.             Thread t = new Thread(r);  

  59.             String threadName = CustomThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);  

  60.             System.out.println(threadName);  

  61.             t.setName(threadName);  

  62.             return t;  

  63.         }  

  64.     }  

  65.       

  66.       

  67.     private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {  

  68.   

  69.         @Override  

  70.         public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {  

  71.             // 记录异常  

  72.             // 报警处理等  

  73.             System.out.println("error.............");  

  74.         }  

  75.     }  

  76.       

  77.       

  78.       

  79.     // 测试构造的线程池  

  80.     public static void main(String[] args) {  

  81.         CustomThreadPoolExecutor exec = new CustomThreadPoolExecutor();  

  82.         // 1.初始化  

  83.         exec.init();  

  84.           

  85.         ExecutorService pool = exec.getCustomThreadPoolExecutor();  

  86.         for(int i=1; i<100; i++) {  

  87.             System.out.println("提交第" + i + "个任务!");  

  88.             pool.execute(new Runnable() {  

  89.                 @Override  

  90.                 public void run() {  

  91.                     try {  

  92.                         Thread.sleep(300);  

  93.                     } catch (InterruptedException e) {  

  94.                         e.printStackTrace();  

  95.                     }  

  96.                     System.out.println("running=====");  

  97.                 }  

  98.             });  

  99.         }  

  100.           

  101.           

  102.           

  103.         // 2.销毁----此处不能销毁,因为任务没有提交执行完,如果销毁线程池,任务也就无法执行了  

  104.         // exec.destory();  

  105.           

  106.         try {  

  107.             Thread.sleep(10000);  

  108.         } catch (InterruptedException e) {  

  109.             e.printStackTrace();  

  110.         }  

  111.     }  

  112. }  


方法中建立一个核心线程数为30个,缓冲队列有10个的线程池。每个线程任务,执行时会先睡眠0.1秒,保证提交40个任务时没有任务被执行完,这样提交第41个任务是,会交给CustomRejectedExecutionHandler 类来处理。