线程池 Executor

new Thread的弊端

• 每次new Thread 新建对象，性能差
• 线程缺乏统一管理，可能无限制的新建线程，相互竞争，可能占用过多的系统资源导致死机或者OOM（out of memory内存溢出）。（这种问题的原因不是因为单纯的new一个Thread，而是可能因为程序的bug或者设计上的缺陷导致不断new Thread造成的）
• 缺少更多功能，如更多执行、定期执行、线程中断。

线程池的好处

1. 降低资源消耗。重复利用已创建的线程，减少线程创建、消亡的开销。
2. 提高响应速度。当任务到达时，可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。（并发数控制，定时/定期执行等）

线程池类图

常用最下边的Executors,用它来创建线程池使用线程。
Executor框架，根据一组执行策略的调用调度执行和控制异步任务，目的是提供一种将任务提交与任务运行分离开的机制。

• Executor:运行新任务的简单接口
• ExecutorService：扩展了Executor，添加了用来管理执行器生命周期和任务生命周期的方法
• ScheduleExcutorService：扩展了ExecutorService，支持Future和定期执行任务

线程池的实现原理

corePoolSize、maximumPoolSize、workQueue 三者关系

• corePoolSize（核心线程数、基本线程数）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务（即使有空闲的基本线程。当任务数大于corePoolSize时就不再创建）。如果调用了线程池prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
• runnableTaskQueue(任务队列) ：workQueue阻塞队列，存储等待执行的任务(运行中的线程数大于corePoolSize且小于maximumPoolSize时)
• maximumPoolSize：线程最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。（如果使用了无界的任务队列，能够创建的最大线程数为corePoolSize,这时maximumPoolSize就不会起作用）

吞吐量：SynchronousQueue高于LinkedBlockingQueue高于ArrayBlockingQueue

ThreadPoolExecutor执行execute（）的4种情况

1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（需要获取全局锁）。
2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。
3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（需要获取全局锁）。
4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

设计思路，是为了在执行execute()方法时，尽可能地避免获取全局锁 （严重的可伸缩瓶颈）。在ThreadPoolExecutor完成预热之后（当前运行的线程数大于等于corePoolSize），几乎所有的execute()方法调用都是执行步骤2，而步骤2不需要获取全局锁。

jdk版本不同会有区别
public void execute(Runnable command) {
    
    
        if (command == null)
            throw new NullPointerException();
         //只有当前线程池中线程数poolSize <corePoolSize 时，则创建线程并执行当前任务 
        //当poolSize >=corePoolSize 或线程创建失败，则将当前任务放到工作队列中。  
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
    
       
            if (runState == RUNNING && workQueue.offer(command)) {
    
    
                //如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量，则创建一个线程执行任务。
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
           //抛出RejectedExecutionException异常
            else if (!addIfUnderMaximumPoolSize(command))
                reject(command); // is shutdown or saturated
        }
    }

工作线程： 线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会循环获取工作队列里的任务来执行（不会被GC）。Worker类的run()方法:

 public void run() {
	    try {
	    	Runnable task = firstTask;
	    	firstTask = null;
	    	while (task != null || (task = getTask()) != null) {
		    	runTask(task);
		    	task = null;
	    	}
	    } finally {
	    	workerDone(this);
    	}
    }

线程池的创建

我们可以通过ThreadPoolExecutor来创建一个线程池。

new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long  keepAliveTime,TimeUnit unit  ,
BlockingQueue<Runnable> workQueue ,ThreadFactory threadFactory, RejectedExecutionHandler handler);

ThreadFactory：线程工厂,设置创建线程，可以通过线程工厂给每个创建出来的线程设置名称。开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字，代码如下。

new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();

RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。

扫描二维码关注公众号，回复： 12616681 查看本文章

.AbortPolicy：直接抛出异常。
·CallerRunsPolicy：使用 【调用者 dubbo生产者主线程】所在线程（execute 方法的调用线程） 来运行任务(可能会影响主线程)。
·DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
·DiscardPolicy：不处理，丢弃掉。

也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务。

keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

TimeUnit:keepAliveTime的时间单位

工厂类Executors三种静态方法详解

向线程池提交任务

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。
通过以下代码可知execute()方法输入的任务是一个Runnable类的实例。

threadsPool.execute(new Runnable() {
	@Override
	public void run() {
		// TODO Auto-generated method stub
	}
});

submit()方法用于提交需要返回值的任务。线程池会返回一个future 类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

Future<Object> future = executor.submit(harReturnValuetask);
	try {
		Object s = future.get();//获取返回值
	} catch (InterruptedException e) {
		// 处理中断异常
	} catch (ExecutionException e) {
		// 处理无法执行任务异常
	} finally {
		// 关闭线程池
		executor.shutdown();
	}

关闭线程池

shutdown或shutdownNow方法关闭线程池。
原理:遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。

区别

• shutdownNow()将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表
• shutdown()将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

其他状态

• SHUTDOWN不能处理新的任务，但是能继续处理阻塞队列中任务
• stop：不能接收新的任务，也不处理队列中的任务
• tidying：如果所有的任务都已经终止了，这时有效线程数为0
• terminated：最终状态

  /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted.
     * Invocation has no additional effect if already shut down.
     */
    public void shutdown() {
    
    
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
    
    
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
    
    
            mainLock.unlock();
        }
        tryTerminate();
    }

  /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks
     * that were awaiting execution. These tasks are drained (removed)
     * from the task queue upon return from this method.
     */
    public List<Runnable> shutdownNow() {
    
    
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
    
    
            checkShutdownAccess();
            advanceRunState(STOP);
            interruptWorkers();
            tasks = drainQueue();
        } finally {
    
    
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

合理地配置线程池

必须首先分析任务特性，可以从以下几个角度来分析。

• 任务的性质：CPU密集型任务、IO密集型任务和混合型任务。
• 任务的优先级：高、中和低。
• 任务的执行时间：长、中和短。
• 任务的依赖性：是否依赖其他系统资源，如数据库连接。

性质不同的任务可以用不同规模的线程池分开处理。

• CPU密集型任务应配置尽可能小的线程，如配置Ncpu+1个线程的线程池。
• 由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*Ncpu。
• 混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没必要进行分解。
• 依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待的时间越长，则CPU空闲时间就越长，那么线程数应该设置得越大，这样才能更好地利用CPU。

可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。
注意：如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。

建议使用有界队列
最大maximumPoolSize，能增加系统的稳定性和预警能力，能够降低资源消耗但是这种方式使得线程池对线程调度变的更困难。
想让【线程池的吞吐率】【处理任务】达到一个合理的范围，使【线程调度相对简单】【尽可能降低资源消耗】合理限制【线程池】与【队列容量】

分配技巧

1. 降低资源消耗【cpu使用率、操作系统资源的消耗、上下文切换的开销】设置一个【较大的队列容量】【较小线程池容量】降低线程池吞吐量
2. 提交的任务经常发生阻塞，可以调整maximumPoolSize
3. 队列容量较小，需要把线程池大小设置的大一些，这样cpu的使用率相对来说会高一些
4. 如果线程池的容量设置的过大，提高任务的数量过多的时候，并发量会增加，需要考虑线程之间的调度。这样反而可能会降低处理任务的吞吐量。

线程池的监控

·taskCount：线程池需要执行的任务数量。
·completedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount。
·largestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。
·getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。
·getActiveCount：获取活动的线程数。

通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的beforeExecute、afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。

protected void beforeExecute(Thread t, Runnable r) {
	这几个方法在线程池里是空方法。
 }