并发编程（五）：Executor框架

简介

Executor是JDK提供的一套线程框架，用于有效的控制线程。

Executor框架主要包含三个部分：

任务：包括Runnable和Callable，其中Runnable表示一个可以异步执行的任务，而Callable表示一个会产生结果的任务

任务的执行：包括Executor框架的核心接口Executor以及其子接口ExecutorService。在Executor框架中有两个关键类ThreadPoolExecutor和ScheduledThreadPoolExecutor实现了ExecutorService接口。

异步计算的结果：包括接口Future和其实现类FutureTask。

Executors创建线程池的方法

Executors框架可以创建几个固定的线程池：

1. newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

2. newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
   newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

3. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

但是有时候这些线程池无法满足我们的需求，这时候就是需要自定义线程池了，这就需要了解ThreadPoolExecutor的各个参数：

public ThreadPoolExecutor(int corePoolSize,                          int maximumPoolSize,                          long keepAliveTime,                          TimeUnit unit,                          BlockingQueue<Runnable> workQueue,                          ThreadFactory threadFactory,                          RejectedExecutionHandler handler) //后两个参数为可选参数

参数说明：

corePoolSize：核心线程数，如果运行的线程少于corePoolSize，则创建新线程来执行新任务，即使线程池中的其他线程是空闲的

maximumPoolSize:最大线程数，可允许创建的线程数，corePoolSize和maximumPoolSize设置的边界自动调整池大小：

corePoolSize <运行的线程数< maximumPoolSize:仅当队列满时才创建新线程

corePoolSize=运行的线程数= maximumPoolSize：创建固定大小的线程池

keepAliveTime:如果线程数多于corePoolSize,则这些多余的线程的空闲时间超过keepAliveTime时将被终止。

unit:keepAliveTime参数的时间单位

workQueue:保存任务的阻塞队列，与线程池的大小有关：当运行的线程数少于corePoolSize时，在有新任务时直接创建新线程来执行任务而无需再进队列，当运行的线程数等于或多于corePoolSize，在有新任务添加时则选加入队列，不直接创建线程当队列满时，在有新任务时就创建新线程

threadFactory:使用ThreadFactory创建新线程，默认使用defaultThreadFactory创建线程

handle:定义处理被拒绝任务的策略，默认使用ThreadPoolExecutor.AbortPolicy,任务被拒绝时将抛出RejectExecutorException

例如：

package com.tgb;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;import java.util.concurrent.ExecutorService;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;public class UseThreadPoolExecutor2 implements Runnable{    private static AtomicInteger count = new AtomicInteger(0);    @Override    public void run() {        try {            int temp = count.incrementAndGet();            System.out.println("任务" + temp);            Thread.sleep(2000);        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static void main(String[] args) throws Exception{        //无界队列        //BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();        //有界队列        BlockingQueue<Runnable> queue =                new ArrayBlockingQueue<Runnable>(10);        ExecutorService executor  = new ThreadPoolExecutor(                    5,      //core                    10,     //max                    120L,   //2fenzhong                    TimeUnit.SECONDS,                    queue);        for(int i = 0 ; i < 20; i++){            executor.execute(new UseThreadPoolExecutor2());        }        Thread.sleep(1000);        System.out.println("queue size:" + queue.size());       //10        Thread.sleep(2000);    }}

有界/无界队列

在使用有界队列时： 若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，若大于corPoolSiz，则会将任务加入队列，若队列已满，则在总线程数不大于maxmumPoolsize的前提下，创建新的线程，若线程数大于maximumPoolSize，则执行拒绝策略，或者其他自定义方式。

核心线程数同生同死；

A+B < C

无界的任务队列：LinkedBlockingQueuee。与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况，当有新任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务；当达到corePoolSize后，就不会继续增加。若后续仍有新的任务加入，则有没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。

Ps：当无界队列限定了数量时，就充当了有界队列的角色；