线程池原理及应用之个人心得

线程池的创建和常用参数分析

• 创建方式,利用Executors创建固定、单个、缓存数量线程的线程池

  package com.myd.cn.ThreadPool;
  
  import java.util.concurrent.ArrayBlockingQueue;
  import java.util.concurrent.BlockingDeque;
  import java.util.concurrent.BlockingQueue;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.ThreadPoolExecutor;
  import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
  import java.util.concurrent.TimeUnit;
  
  public class ThreadPoolDemo {
  	public static void test(){
  		//第一种方式，使用Executors.newFixedThreadPool(10)
  		//ExecutorService executorService = Executors.newFixedThreadPool(10);
  		//第二种，使用new ThreadPoolExecutor(方法签名)，指定具体参数，设置拒绝策略
  		BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue(100);
  		AbortPolicy rejectPolicy = new AbortPolicy();
  		//keepaliveTime设置为0，意味线程空闲多久都不退出
  		ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 0, TimeUnit.SECONDS, workQueue,rejectPolicy);
  		//设置拒绝策略
  		//pool.setRejectedExecutionHandler(rejectPolicy);
  		//使用lambda方式向线程池提交任务
  		pool.execute(()->{
  			System.out.println("lambda style is executed");
  		});
  	}
  
  	public static void main(String[] args) {
  		 test();
  	}
  }
  
  

• 参数解析
  • corePoolSize,线程池核心线程数量
  • maximumPoolSize,线程池能够启动的最大线程数量
  • keepAliveTime,设置线程空闲的最大时间，超过改时间，线程退出
  • TimeUnit unit,设置线程空闲的最大时间的单位，秒，小时，分钟等
  • BlockingQueue workQueue,线程池线程全部占用，无法满足后续任务的执行，会使用拒绝策略，此为配合拒绝策略使用的工作队列
    • ArrayBlockingQueue

      1.是有界设计，如果容量满无法继续添加，纸质有元素被移除才能继续添加新的就绪任务。
      2.数组性阻塞队列，初始化一定容量的数组
      3.使用一个重入锁(默认非公平),入队和出队共用一个锁，互斥。
      4..数组型，使用时开辟连续内存，若初始容量过大易造成资源浪费，过小易添加失败。
      

    • LinkBlockqueue，链表方式实现，内部使用节点管理，会产生多一点内存占用

      1.有边界设计，默认构造方法容量是Integer.MAX_VALUE
      2.使用两个重入锁分布控制元素的入队和出队，用Condition(条件变量，可以在线程间唤醒和等待绑定多余一个的条件)
      3.链表实现，申请空间是非连续性
      

    • DelayQueue

      1.无边界设计
      2.添加(put)不阻塞，移除(remove)时阻塞
      3.元素都有一个过期时间
      4.取元素时只有过期的才会被取出
      

    • SynchronousQueue

      1.内部容量为0
      2.每次删除都要等待插入操作
      3.每次插入都要等于删除操作
      4.一个元素，一旦有了插入线程和移除线程，那么很快由插入线程移交移除线程，该容器相当于通道本身不存储元素
      5.多任务队列中，是最快的处理方式
      

    • PriorityBlockingQueue

      1.无边界设计，容量依靠自有系统资源影响(资源多则多分配，少则少分配)
      2.添加元素，如果超过1，则进入优先级排序
      

  • RejectedExecutionHandler handler,当线程池所有线程被占用，无法满足后续任务的时候，采用拒绝策略，保证线程安全运行
    • AbortPolicy,默认策略,丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行
    • CallerRunsPolicy,当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大
    • DiscardPolicy , 直接丢弃，其他啥都没有
    • DiscardOldestPolicy - 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

线程池状态

• SHUTDOWN，关闭状态,调用shutdown()方法后从从RUNNING状态进入到这个状态，此时新的任务不再接受，旧的任务执行完毕后停止
• STOP,停止状态，调用shutdownNow()方法后从RUNNING状态进入到这个状态，此时新的任务不再接受，旧的任务中断执行
• TIDYING,整理状态，此时队列经历SHUTDOWN或STOP状态后，此时队列中任务数量已经是0
• TERMINATED,终结状态，由TIDYING状态后terminated()后进入该状态
• 变化图示
  

可定时执行的线程池原理分析

• 适用创建

  1.定时执行异步任务周期性执行异步任务,例子如下
  
  2.当前时间开始，每个5s打印 "is Running"
  	package com.myd.cn.ThreadLocal;
  	
  	import java.util.concurrent.ScheduledThreadPoolExecutor;
  	import java.util.concurrent.TimeUnit;
  	
  	public class ScheduledExecutorPoolDemo {
  		public static void testScheduledThreadPoolExecutor() throws Exception {
  			ScheduledThreadPoolExecutor scheduledExecutorPool = new 	ScheduledThreadPoolExecutor(10);
  			scheduledExecutorPool.scheduleAtFixedRate(()->{
     				 System.out.println("is Running");
     			}, 0, 5, TimeUnit.SECONDS);	 
  	}
  	public static void main(String[] args) throws Exception {
  		 testScheduledThreadPoolExecutor();
  	  }
  	}
  3.输出结果
  	is Running
  	is Running
  	is Running
  

• ScheduledExecutorService注意点

  1.线程从和异常的监控和告警，及时了解任务运行状况
  2.周期性执行任务，需要注意任务的执行时间，避免业务影响
  3.注意异常处理，抛出异常后，任务将终止周期执行
  

定时执行线程池原理

• 线程池worker + 时间任务队列，每个定时任务对于小顶堆的节点值，根据节点值判断执行次序
  
• 小顶堆结构构造延时任务队列控制任务执行时间，次数

定时任务执行流程

• 调用execute方法执行，execute方法触发schedule（）方法，来设置超时时间

  public void execute(Runnable command) {        
  schedule(command, 0, NANOSECONDS);
  }
  

• schdule方法调用decorateTask方法，设置提交任务的定时执行时间(距现在多久)

  public ScheduledFuture<?> schedule(Runnable command,                                       long delay,                                       TimeUnit unit) {        
  if (command == null || unit == null)            
  throw new NullPointerException();        
  RunnableScheduledFuture<?> t = decorateTask(command,            new ScheduledFutureTask<Void>(command, null,                                          triggerTime(delay, unit)));        
  delayedExecute(t);        
  return t;
  } 
  2.修改和替换用来执行一个runnable的任务
  protected <V> RunnableScheduledFuture<V> decorateTask(       				 Runnable runnable, RunnableScheduledFuture<V> task) {        				
   return task;   
    }
  3.设置触发事件(距现在多久执行) 			
  private long triggerTime(long delay, TimeUnit unit) {        			
  return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
  } 
  

• excute(()->{runnalbe方法}) 最终执行Runnable的run方法，ScheduledThreadPoolExecutor会先判断是否是周期执行任务
• 如果当前线程池状态不出入RUNNING和shutdown,则无法执行周期任务，需要取消
• 如果是非周期任务，则立即执行
• 如果是周期任务，则执行周期任务，并设置下次任务触发事件。若本次任务执行失败，则无法设置下次任务执行时间，因此要对程线程池执行状况和异常进行监控和告警
• 源码

  public void run() {            
  boolean periodic = isPeriodic();            
  if (!canRunInCurrentRunState(periodic))                
  	cancel(false);            
  else if (!periodic)               
  	ScheduledFutureTask.super.run();            
  else if (ScheduledFutureTask.super.runAndReset()) {                
  	setNextRunTime();                
  	reExecutePeriodic(outerTask);            
  	}        
  }