线程池与死锁定位分析

为什么使用线程池？优势

查看本机的cpu核数：Runtime.getRuntime().availableProcessors()、

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后再线程创建后启动这些任务，如果线程数量超过了最大数量 超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行
他的主要特点：线程复用；控制最大并发数；管理线程。
第一：降低资源消耗。通过复用利用已创建的线程降低线程创建和销毁造成的消耗
第二：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

线程池3个常用方式

线程池架构

java中线程池是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个类

					（I）Executor
								|
					 (I) ExecutorService
					 			|
(C)AbstractExecutorService (I)ScheduleExecutorService
			|									|
(C)ThreadPoolExecutor							|
			|									|
			-------------------------------------
							|
			SchedulerThreadPoolExecutor 						 

编码实现

了解

• Executors.newScheduledThreadPool() 使用目前机器上可用的处理器作为他的并行级别
• **java8新增：Executors.newWorkStealingPool(int) **

重点(底层ThreadPoolExecutor)

demo

//        ExecutorService executorService = Executors.newFixedThreadPool(5);
//        ExecutorService executorService = Executors.newSingleThreadExecutor();
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 模拟需要 办理 20个业务
        try{
            for (int i = 1; i <= 20; i++) {
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"  业务处理");
                });
            }
        }catch (Exception e){
          e.printStackTrace();
        }finally {
           executorService.shutdown();
        }

• Executors.newFixedThreadPool(int)

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

主要特点如下：

1. 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
2. newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的是LinkedBlockingQueue

• Executors.newSingleThreadExecutor()

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

主要特点如下：

1. 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行
2. newSingleThreadExecutor()将corePoolSize和maxmumPoolSize都设置为1，它使用LinkedBlckingQueue

• Executors.newCachedThreadPool()

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

主要特点如下

1. 创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
2. newCacheThreadPool将CorePoolSize设置为0，将maxmumPoolSize设置为Integer.MAX_VALUE,使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程

线程池的几个重要的参数

7大参数

corePoolSize

线程池中的常驻核心线程数

maximumPoolSize

线程池能够容纳同时执行的最大线程数，此值必须大于等于1

keepAliveTime

多余的空闲线程的存活时间。
当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁知道只剩下corePoolSize个线程为止

unit

keepAliveTime的单位

workQueue

任务队列，被提交单尚未被执行的任务

threadFactory

表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认即可

handler

拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时，如何拒绝请求执行的runnable的策略

线程池的工作原理

工作原理

1. 在创建了线程池后，等待提交过来的任务请求

2. 当调用execute()方法添加一个请求任务时，线程池会做如下判断
   currentRunThreadSize:当前运行线程数
   corePoolSize： 核心线程数
   maximumPoolSize： 最大线程数

   • 如果currentRunThreadSize < corePoolSize，那么马上创建线程运行这个任务
   • 如果currentRunThreadSize >= corePoolSize，那么将这个任务放入队列
   • 如果这时候队列满了且currentRunThreadSize < maximumPoolSize，那么要创建非核心线程数运行这个任务
   • 如果队列队列满了并且currentRunThreadSize >= maximumPoolSize，那么线程池会启动饱和拒绝策略来执行

3. 当一个线程完成任务时，他会从队列中取下一个任务来执行

4. 当线程无事可做超过一定时间（keepAliveTime）时，线程池会判断；

   • 如果currentRunThreadSize > corePoolSize那么这个线程就会被停掉
   • 如果线程池的所有任务完成后最终会收缩到corePoolSize的大小

如何配置合理参数

线程池的拒绝策略

是什么

核心线程数满了，阻塞队列满了，最大线程数也满了，使用拒绝策略

JDK内置的拒绝策略

1. AbortPolicy（默认）：直接抛出RejectExecutionException异常阻止系统正常运行
2. CallerRunsPolicy：“调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常而是将某些任务回退给调用者，从而降低先任务的流量
3. DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中，尝试再次提交当前任务
4. DiscardPolicy：直接丢弃任务，不予任务处理也不抛出异常。如果允许任务丢失，这是最好的方案

以上内置的拒绝策略均实现了RejectExecutionHandler接口

你在工作中单一的/固定数/可变的三种创建线程池的方法，你用的哪个多？

一个都不用
参考alibaba java 手册

1. 【强制】线程资源必须通过线程池提供，不允许在应用中显式创建线程
2. 【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样处理方式让写的同学更加明确线程池的规则，规避资源耗尽的风险

合理配置线程池您是如何考虑的？

CPU密集型

cpu密集型的意思是该任务需要大量的运算，而没有阻塞，cpu一直全速运行
cpu密集任务只有在真正的多核cpu上才肯能得到加速（通过多线程）
而在单核cpu（悲剧 ！！！），无论你开几个模拟多线程该任务都不可能得到加速，因为cpu总的运算能力就那些
cpu密集型任务配置尽可能少的线程数量：
一般公式：cpu核数+ 1个线程

IO密集型

方案一

由于IO密集型任务线程并不是一直执行任务，则应配置尽可能多的线程，如cpu核数 * 2

方案二

IO 密集型，该任务需要大量IO，即大量的阻塞
在单线程上运行IO密集型的任务会导致浪费大量的cpu运算能力在等待，所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核cpu上，这种加速主要就是利用被浪费掉的阻塞时间
IO密集型时，大部分线程都是阻塞的，故需要多配置线程数：
参考公式：cpu核数/(1 - 阻塞系数) 阻塞系数： 0.8-0.9之间
比如8和cpu: 8/(1-0.9)= 80个线程

死锁定位与分析

是什么

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉那么他将无法推进下去，如果系统资源充足，进程的资源都能够得到满足，死锁的出现可能性就很低，否则就会出现争夺有限的资源而陷入死锁

demo

class HoldLockThread implements Runnable{
    private String lockA;
    private String lockB;

    public HoldLockThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName() + " 自己持有" + lockA + " 尝试获取" + lockB);
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {e.printStackTrace();}
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName() + " 自己持有" + lockB + " 尝试获取" + lockA);

            }
        }
    }
}
public class HoldLockDemo {
    public static void main(String[] args) {
         String lockA = "lockA";
         String lockB = "lockB";
         new Thread(new HoldLockThread(lockA,lockB),"threadAAA").start();
         new Thread(new HoldLockThread(lockB,lockA),"threadBBB").start();
    }

}

定位分析：

1. 打开终端，输入jps
   
2. jstack 31691
   
   生产环境中，发现死锁，直接重启服务器