Java面试高频技术线程池，源码笔记答案全纪录

线程数 = 核数 * 期望 CPU 利用率 * 总时间(CPU计算时间+等待时间) / CPU 计算时间

例如 4 核 CPU 计算时间是 50% ，其它等待时间是 50%，期望 cpu 被 100% 利用，套用公式
4 * 100% * 100% / 50% = 8

例如 4 核 CPU 计算时间是 10% ，其它等待时间是 90%，期望 cpu 被 100% 利用，套用公式
4 * 100% * 100% / 10% = 40

提交一个任务到线程池中，线程池的处理流程如下：

流程1 判断核心线程数
判断正在运行的工作线程是否小于 设置的核心线程数，小于尝试创建一个
新的工作线程，如果不小于进入下一流程

流程2 判断任务队列
判断当前线程池的任务队列是否已满,未满的话将任务加入任务队列,如果满了,进入下一个流程

流程3 判断最大线程数
判断当前线程池的工作线程是否小于 设置的最大线程数，小于尝试创建一个新的临时工作线程，如果不小于进入下一流程


流程4 判断 饱和/拒绝 策略			
到此流程，说明当前线程池已经饱和，需要进行拒绝策略,根据设置的拒绝策略进行处理

在线程池中，线程被创建后执行完任务后  不会立刻销毁

而是线程的任务本身就是一个while循环  通过getTask()方法  从workQueue 任务队列中调用要执行的任务， 

获取到任务后， 会执行任务的run方法， 这样实现了任务的复用

线程池中线程停止有下面几种情况:
1. 线程池中核心线程默认永远不会销毁 (可以通过allowCoreThreadTimeOut设置允许超时)，
   而临时线程  如果空闲时间达到 keepAlivedTime + TimeUnit的值后 会被销毁

2. 如果调用线程池的 shutDown方法， 线程池会在workQueue中的任务执行完毕后 销毁所有线程，关闭线程池

3. 如果调用线程池的 shutDownNow方法， 线程池会立刻终止 ， workQueue中的未完成任务 会作为返回值返回

如果线程池 中工作线程数量已经达到最大线程，并且任务队列已满，说明线程池已经达到饱和状态

会执行参数中传入的拒绝策略 (实现 RejectedExecutionHandler接口 )

ThreadPoolExecutor中 内置了4种拒绝策略:
	
	CallerRunsPolicy: 不丢弃任务，让线程池的调用者线程 参与执行任务
	 
	AbortPolicy: 丢弃后续的任务，并抛出异常
	
	DiscardOldestPolicy: 丢弃任务队列中 存放最久的任务，不抛异常
	
	DiscardPolicy: 丢弃后续任务，不抛异常

SynchronousQueue没有容量，是无缓冲等待队列，是一个不存储元素的阻塞队列，会直接将任务交给消费者，必须等队列中的添加元素被消费后才能继续添加新的元素。
使用SynchronousQueue阻塞队列一般要求maximumPoolSizes为无界，避免线程拒绝执行操作。

LinkedBlockingQueue是一个无界缓存等待队列。当前执行的线程数量达到corePoolSize的数量时，剩余的元素会在阻塞队列里等待。（所以在使用此阻塞队列时maximumPoolSizes就相当于无效了），每个线程完全独立于其他线程。生产者和消费者使用独立的锁来控制数据的同步，即在高并发的情况下可以并行操作队列中的数据。

ArrayBlockingQueue是一个有界缓存等待队列，可以指定缓存队列的大小，当正在执行的线程数等于corePoolSize时，多余的元素缓存在ArrayBlockingQueue队列中等待有空闲的线程时继续执行，当ArrayBlockingQueue已满时，加入ArrayBlockingQueue失败，会开启新的线程去执行，当线程数已经达到最大的maximumPoolSizes时，再有新的元素尝试加入ArrayBlockingQueue时会报错。

Executors是线程池的工具类，提供了四种快捷创建线程池的方法：


newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newSingleThreadExecutor 
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

/**
     * 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
     */
    public void fun1(){
        // 创建线程池
        ExecutorService es = Executors.newCachedThreadPool();
        // 会创建出10个线程   分别执行任务
        for (int i = 0; i {
                for (int j = 0; j 

/**
     * 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     */
    public void fun2(){
        // 创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        // 会创建出10个线程   分别执行任务
        for (int i = 0; i {
                try {
                    Thread.sleep(400);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int j = 0; j 

/**
     * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
     */ 
public void fun3(){
        // 创建线程池
        ExecutorService es = Executors.newSingleThreadExecutor();
        // 会创建出10个线程   分别执行任务
        for (int i = 0; i {
                try {
                    Thread.sleep(400);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int j = 0; j 

/**
     * 创建一个定长线程池，支持延迟及周期性任务执行。延迟执行示例代码如下
     */
    public void fun4(){
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        // 周期性执行任务（任务会执行多次）
        // 参数1：任务   参数2：延迟时间   参数3：每隔长时间   参数4：时间单位
        newScheduledThreadPool.scheduleAtFixedRate(()-> System.out.println("要执行的任务"), 3, 2, TimeUnit.SECONDS);
        // 延迟执行任务（任务执行一次）
        // 参数1：任务   参数2：延迟时间   参数3：时间单位
        newScheduledThreadPool.schedule(()->System.out.println("要执行的任务"), 3,TimeUnit.SECONDS);
    }

注意:
scheduleAtFixedRate ，是以上一个任务开始的时间计时，period时间过去后，检测上一个任务是否执行完毕，如果上一个任务执行完毕，则当前任务立即执行，如果上一个任务没有执行完毕，则需要等上一个任务执行完毕后立即执行。

scheduleWithFixedDelay，是以上一个任务结束时开始计时，period时间过去后，立即执行。

// 工作线程的集合
HashSet workers = new HashSet();

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable

{
		// 执行工作的线程对象
        final Thread thread;
		// Worker要执行的第一个任务
        Runnable firstTask;
}

Worker(Runnable firstTask) {
            setState(-1); 
    		// 传入worker第一次要执行的任务
            this.firstTask = firstTask;
    		// 使用工厂对象创建线程, 并把worker本身传入
            this.thread = getThreadFactory().newThread(this);
}

public Thread newThread(Runnable r) {
    // new 了一个新的线程对象  并且把worker对象作为线程任务传入
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            return t;
}

// 线程任务 run方法
public void run() {
   runWorker(this);
}
// Worker的核心工作方法
final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
    	// 第一次要执行的任务 赋值给task
        Runnable task = w.firstTask;
       ...
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
					... 
                        // 执行任务的run方法
                        task.run();
                    ...
                } finally {
                	// 任务执行完毕后，清空任务判断是否包含下一个任务
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

private Runnable getTask() {
        boolean timedOut = false; 
        for (;;) {
            ...
            try {
                Runnable r = timed ?
                   // 下面两种方法都是在从 workQueue队列中获取任务
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                // 将取到的任务返回
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

小结:
通过上面的源码分析得出，Worker对象是线程池工作的核心，一个Worker对象代表一个工作线程， 只要Worker内的线程的start方法被调用后，我们的worker对象内的run方法被线程执行，而run方法中则不断的从任务队列中获取 任务，并调用任务的run方法来执行，这样就达到了线程复用的目的。  

那么Worker什么时候会被创建呢? 

接着分析线程池的execute执行任务的方法

// execute执行方法源码分析
		public void execute(Runnable command) {
			// 任务为空抛异常
			if (command == null)
				throw new NullPointerException();
			// ctl 是 integer原子类  主要通过它记录两类信息，
			// ctl作用: 1.记录线程池状态    2.记录线程池工作线程数量 
			// workerCountOf(c):判断worker数量 
			// isRunning(c): 判断线程池状态
			// 1.如果当前worker数量小于corePoolSize  创建一个新的worker
			int c = ctl.get();
			if (workerCountOf(c)  添加核心工作线程   false => 添加临时工作线程   
			else if (!addWorker(command, false))
				
				// 4. 如果添加失败，执行拒绝策略
				reject(command);
		}

总结:通过execute方法的源码，我们就已经看到了执行流程

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
				...
         // wc是工作线程的数量
         // core为true 判断是否大于核心线程数量
         // core为false 判断是否大于最大线程数量
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                ...
            }
        }
		// 准备创建worker
        Worker w = null;
        try {
            // 创建worker对象，构造器内会通过线程工厂创建一个线程  并且把worker对象作为任务传入
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                   ...
                   // 将worker对象 存入到workers集合
                   workers.add(w);
                   int s = workers.size();
                   if (s > largestPoolSize)
                      largestPoolSize = s;
                      workerAdded = true;
                }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    // 启动worker内的线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

小结:
可以看到，在execute方法中完全和我们前面将的流程一样，在addWorker方法中通过构造器创建了worker对象  并把它存入到了workers集合中，然后启动worker内线程的start方法，这样这个worker就会不断工作，不断的执行任务队列里面的任务

## 线程池实战场景

### 异步处理

在头条项目中，  热点评论的计算  和 搜索历史的记录需要异步执行， 使用spring提供的 @EnableAsync    @Async使用线程池



### 并行请求

在电商项目的商品详情功能，要显示的数据分类非常多，需要从不同的微服务中获取，  如果直接的挨个调用Feign方法查询，使用串行方案效率很低，下面的商品详情是通过定义**Callable**任务， 在通过**线程池**异步的执行查询，最终汇总结果




### 并行处理



某公司每隔一个周期，会生成所有合作供应商的结算单，在定时任务中，查询所有供应商信息，因为每个供应商都需要统计相关数据，采用串行方案效率低，可以使用线程池 ，通过多个线程并行处理任务