详解线程池

线程池了解

1、为什么要有线程池？

答：线程池出现的原因：
假设每当一个请求到达就创建一个新的线程，为每个请求在创建和销毁线程上花费的时间和消耗的资源有可能比花在处理实际的用户需求的时间和资源还多。而且大多数的实际场景处理某一次请求的时间是非常短暂的，但是请求的数量会很多，如果我们为每次请求单独创建一个新的线程，那么基本上的所有资源基本上都是被操作系统创建线程，切换线程状态，销毁线程这些操作所占有，使用线程池就可以将线程进行统一的分配，调度和监控。并且，对操作系统中最大的线程数量是有限制的，也不会使得操作系统因为线程数量过多而不稳定
线程池的优点：
第一：==降低资源消耗。==通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：==提高响应速度。==当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：==提高线程的可管理性。==线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

2、线程池的类的继承关系?

答：

**Executor接口：**所有的线程池都实现了它的接口
只有一个方法execute();，接受任务并执

ExecutorService接口：
继承Executor接口

AbstractExecutorService抽象类：
实现了ExecutorService接口，里面有一种提交线程的方法submit方法
由下面的可以看出用submit提交线程，无论是用runnable还是callable最后都封装成FutureTask进行提交任务

3、ThreadPoolExecutor的研究

继承关系：

基本属性：

	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));//记录线程池状态和线程数量（总共32位，前三位表示线程池状态，后29位表示线程数量）
    private static final int COUNT_BITS = Integer.SIZE - 3;//线程数量统计位数29  Integer.SIZE=32 
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;//容量 
    
/*线程池状态*/
    private static final int RUNNING    = -1 << COUNT_BITS;//运行中 ：接受新任务并且继续处理阻塞队列中的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;//关闭 ：不接受新任务但是会继续处理阻塞队列中的任务
    private static final int STOP       =  1 << COUNT_BITS;//停止 ：不接受新任务，不在执行阻塞队列中的任务，中断正在执行的任务
    private static final int TIDYING    =  2 << COUNT_BITS;//整理 ：所有任务都已经完成，线程数都被回收，所有任务都执行完（包含阻塞队列里面任务）当前线程池活动线程为0
    private static final int TERMINATED =  3 << COUNT_BITS;

private static int runStateOf(int c)     { return c & ~CAPACITY; }//获取运行状态（获取前3位）（取反 相与）
private static int workerCountOf(int c)  { return c & CAPACITY; }//获取线程个数（获取后29位）
private static int ctlOf(int rs, int wc) { return rs | wc; }//将运行状态和线程个数合并

private final ReentrantLock mainLock = new ReentrantLock(); //主锁    
private final HashSet<Worker> workers = new HashSet<Worker>();  //工作线程集合
private final Condition termination = mainLock.newCondition(); //条件对象

构造函数：

/*7个参数*/
1.corePollSize：//核心线程数。在创建了线程池后，线程中没有任何线程，等到有任务到来时才创建线程去执行任务。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。
2.maximumPoolSize：//最大线程数。表明线程中最多能够创建的线程数量。
3.keepAliveTime：//空闲的线程保留的时间。
4.TimeUnit：//空闲线程的保留时间单位。
5.BlockingQueue<Runnable>：//阻塞队列，存储等待执行的任务。参数有ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue可选。
6.ThreadFactory：//线程工厂，用来创建线程
7.RejectedExecutionHandler：//队列已满，而且任务量大于最大线程的饱和处理策略

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit, 
                              BlockingQueue<Runnable> workQueue, 
                              ThreadFactory threadFactory, 
                              RejectedExecutionHandler handler) {    
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||  //最大运行线程数必须大于核心线程数
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory; //线程工厂
        this.handler = handler; //拒绝策略
    }

阻塞队列有4种：
（1）ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序。
（2）LinkedBlockingQueue：一个基于链表结构的无界阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
（3）SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于Linked-BlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。不排队，直接提交。
（4）PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：
（1）ThreadPoolExecutor.AbortPolicy:默认策略，丢弃任务并抛出RejectedExecutionException异常。
（2）ThreadPoolExecutor.DiscardPolicy：直接丢弃任务，但是不抛出异常。
（3）ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行当前任务（重复此过程）。
（4）ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

重要方法介绍：
1，线程池提交任务
答：可以使用两个方法向线程池提交任务，分别为execute()和submit()方法。

a.execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。
execute方法：
（1）判断当前线程池中的线程数是否小于核心线程数corePoolSize，小于则创建一个新线程执行任务；
（2）判断如果当前线程池中的线程数大于等于核心线程数corePoolSize，并且workQueue队列未满，则将该线程放入阻塞队列中，并且当前线程池的状态是运行态；
（3）判断如果线程池中的线程数量大于等于corePoolSize，且队列workQueue已满，但线程池中的线程数量小于maximumPoolSize，则会创建新的线程来处理被添加的任务；
（4）如果线程池中的线程数量等于了maximumPoolSize，就用RejectedExecutionHandler来执行拒绝策略；

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();//获取线程池中的线程数量
        if (workerCountOf(c) < corePoolSize) {//线程池中线程数量小于corePoolSize，直接调用addWorker添加新线程执行任务返回。
            if (addWorker(command, true))
                return;
            c = ctl.get();//因为多线程的关系，上一步可能调用addWorker失败（其它线程创建了，数以数量已经超过了），重启获取线程数量。
        }
        if (isRunning(c) && workQueue.offer(command)) {//向workQueue添加添加任务，如果添加成功,再次获取线程数量
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))//再次检查后发现线程池已经关闭或者数量超出，回到已经添加的任务（remove（command））并且执行拒绝策略。
                reject(command);
            else if (workerCountOf(recheck) == 0)//再次检查通过，添加一个新线程。 
                addWorker(null, false);
        }
        else if (!addWorker(command, false))//再次添加线程，失败则调用拒绝策略。
            reject(command);
    }

addWorker方法：
第一层的for循环：判断线程池的状态
第二层的for循环：判断线程的数量

线程池的state越小越是运行状态，runnbale=-1，shutdown=0,stop=1,tidying=2，terminated=3

• 1、如果线程池state已经至少是shutdown状态了
• 2、并且以下3个条件任意一个是false
• rs == SHUTDOWN （隐含：rs>=SHUTDOWN）false情况： 线程池状态已经超过shutdown，可能是stop、tidying、terminated其中一个，即线程池已经终止
• firstTask == null （隐含：rs = =SHUTDOWN）false情况： firstTask不为空，rs= =SHUTDOWN 且 firstTask不为空，return false，场景是在线程池已经shutdown后，还要添加新的任务，拒绝
• ! workQueue.isEmpty() （隐含：rs= =SHUTDOWN，firstTask= =null）false情况： workQueue为空，当firstTask为空时是为了创建一个没有任务的线程，再从workQueue中获取任务，如果workQueue已经为空，那么就没有添加新worker线程的必要了
• return false，即无法addWorker()

 private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) { //CAS操作， 将线程池数量+1
            int c = ctl.get(); 
            int rs = runStateOf(c);// 当前线程池状态
            if (rs >= SHUTDOWN &&  //shutdown状态或者别的非运行状态
                ! (rs == SHUTDOWN &&  //不再接受新的任务，等待线程执行完毕
                   firstTask == null && //传入任务为空
                   ! workQueue.isEmpty())) //阻塞队列为空时，后面结果为True
                return false;
            //要么处于running状态要么shutdown状态下还有线程在执行，可以添加
            for (;;) { 
                int wc = workerCountOf(c); //正在运行线程数量
                if (wc >= CAPACITY ||  //正在运行线程数量大于等于容量
                    //线程数量不能大于最大容量
                    wc >= (core ? corePoolSize : maximumPoolSize)) 
                    // true用核心线程数量比较，false用最大线程数量比较
                    return false;
				  //CAS将线程数+1，在线程池为将要添加的线程留出空间
                if (compareAndIncrementWorkerCount(c)) //CAS将线程数量自增1
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs) //检查一下运行状态是否改变，
                //如果改变将从外循环开始执行，再次确认能否添加任务。
                    continue retry; 
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        boolean workerStarted = false; //线程是否启动
        boolean workerAdded = false; //线程是否添加成功
        Worker w = null;
        try {
            final ReentrantLock mainLock = this.mainLock; //得到一个重入锁
            w = new Worker(firstTask);  //创建一个工作任务
            final Thread t = w.thread; //当前任务线程
            if (t != null) { //线程不为空
                mainLock.lock(); //加锁
                try {
                    int c = ctl.get(); 
                    int rs = runStateOf(c);  //线程状态
                    if (rs < SHUTDOWN || //线程池处于运行状态
                        (rs == SHUTDOWN && firstTask == null)) {//线程池全部线程死掉，创建一个空线程
                        if (t.isAlive()) // precheck that t is startable
                        //线程已经启动，并且没有异常返回true。在这里已经启动的线程任务是不需要添加的，需要抛出异常
                            throw new IllegalThreadStateException();	
                        workers.add(w); //将线程加入到线程池中
                        int s = workers.size();  //线程池线程数量
                        if (s > largestPoolSize) //修正最多运行线程值
                            largestPoolSize = s; //最多时工作线程数量
                        workerAdded = true; //线程添加成功标志
                    }
                } finally {
                    mainLock.unlock(); //解锁
                }
                if (workerAdded) { //线程添加线程池成功，启动线程
                    t.start(); 
                    workerStarted = true; //线程开启成功标志
                }
            }
        } finally {
            if (! workerStarted) //线程未启动成功，从线程池中删除线程并且回滚线程池元素个数
                addWorkerFailed(w);
        }
        return workerStarted; //线程启动成功才算添加完成
    }
    private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null) //线程
                workers.remove(w); //工作线程集合删除
            decrementWorkerCount(); //线程数量-1
            tryTerminate(); //尝试终止线程
        } finally {
            mainLock.unlock();
        }
    }

b.submit()方法用于提交需要返回值的任务。此方法属于AbstractExecutorService抽象类，线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值。
2，线程池终止
答：可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。
shutdown方法：不在接受任务，但是会将正在执行的执行完。

 public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess(); //校验访问许可，
            advanceRunState(SHUTDOWN);//将其设置为shutdown
            interruptIdleWorkers();  //中断所有空闲线程
            onShutdown(); 
        } finally {
            mainLock.unlock();
        }
        tryTerminate();//尝试关闭线程池
    }
 
 final void tryTerminate() {
      //自旋尝试关闭线程池  
        for (;;) {
            int c = ctl.get();
			//如果线程池正在运行，或正在关闭且任务队列不为空，则返回  
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            if (workerCountOf(c) != 0) { // Eligible to terminate
            //如果工作线程不为空，则中断空闲工作线程
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
				 //线程池已关闭，任务队列为空，工作线程为0，更新线程池状态为TIDYING  
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
						//执行结束工作
                        terminated();
                    } finally {
                    //线程池已结束
                        ctl.set(ctlOf(TERMINATED, 0));
					//唤醒等待线程池结束的线程
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
        }
    }

shutdownNow方法：立即中断所有线程。

    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
        //判断调用者是否有权限shutdown线程池
            checkShutdownAccess();
            //CAS+循环设置线程池状态为stop
            advanceRunState(STOP);
             //中断所有线程，包括正在运行任务的
            interruptWorkers();
            tasks = drainQueue();//将workQueue中的元素放入一个List并返回
        } finally {
            mainLock.unlock();
        }
         //尝试终止线程池
        tryTerminate();
        //返回workQueue中未执行的任务
        return tasks;
    }

原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。

4、Executors静态工厂几种常用线程池

1、 Executors.newCacheThreadPool()：无限大小的线程池

可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，适用于很多短期任务的小程序，负载较轻的服务器任务一来就能处理

public class Dome1 {
    public static void main(String[] args) {
        //创建一个可缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            try {
                //sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    //打印正在执行的缓存线程信息
                    System.out.println(Thread.currentThread().getName()+"正在被执行");
                }
            });
        }
    }
 }

2、Executors.newFixedThreadPool(int n)：固定大小的线程池

创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
适用于为了满足资源管理的需求而需要限制当前线程数量的应用场合，适用于负载比较重的服务器

public class Dome2 {
    public static void main(String[] args) {
        //创建一个可重用固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        //打印正在执行
                        System.out.println(Thread.currentThread().getName()+"正在被执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
             });
        }
    }
}

3、Executors.newSingleThreadExecutor() ： 单线线程

作用：该方法返回一个只有一个线程的线程池，即每次只能执行一个线程任务，多余的任务会保存到一个任务队列中，等待这一个线程空闲，当这个线程空闲了再按FIFO方式顺序执行任务队列中的任务。使用于需要保证顺序的执行各个任务，并且在任意时间点，不会有多个线程活动的场景

public class Dome3 {
    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        //结果依次输出，相当于顺序执行各个任务
                        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

4、Executors.newScheduledThreadPool() ： 定时调度池

作用：该方法返回一个可以控制线程池内线程定时或周期性执行某任务的线程池。

public class Dome4 {
    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("延迟1秒执行");
            }
            }, 1, TimeUnit.SECONDS);
    }
}

学会使用线程池

首先编辑一个需要多线程完成的任务类，重写它的run方法

 class Task implements Runnable{
    private int taskNum;
    public Task(int taskNum) {
        super();
        this.taskNum = taskNum;
    }
    @Override
    public void run() {
        System.out.println("正在执行task"+taskNum);
        try {
            Thread.currentThread().sleep(4000);//sleep 4秒模拟执行代码过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task"+taskNum+"执行完毕");
    }
}

有了任务类后，接下来就创建线程池，执行多个任务。使用ThreadPoolExecutor来创建线程池。
使用的是ThreadPoolExecutor下的execute进行任务的提交。

public class Dome5 {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200,
                TimeUnit.MILLISECONDS, new LinkedBlockingDeque<Runnable>());
        for (int i = 0; i < 15; i++) {
            Task myTask = new Task(i);
            executor.execute(myTask);
            System.out.println("线程池中线程数量是："+executor.getPoolSize()+
                    ",线程池中等待执行的任务数是："+executor.getQueue().size()+
                    ",已执行完的任务数是："+executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }
}