Java线程池

为什么使用线程池？

• 为了减少线程频繁创建和消费所产生的性能开销
• 方便对线程进行一些维护和管理（定时开始，周期执行，并发数控制）

创建线程池的的四个方法？

Java 5建议使用 Executors 工具类来得到 Executor 接口的具体对象

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

 ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

2. 创建一个定长的线程池，可控制线程最大并发数，超出的线程会在队列中等待.newFixedThreadPool

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

3. 创建一个定长线程池，支持定时及周期性任务执行。延迟执行。newScheduledThreadPool

ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3);

    4.创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行newSingleThreadExecutor

ExecutorService sigleThreadExecutor=Executors.newSingleThreadExecutor();

其实这四种方法的实现 都是 new 了一个 ThreadPoolExecutor出来！

Executors 提供了以下一些 static 的方法：

callable(Runnable task)：     	   将 Runnable 的任务转化成 Callable 的任务。

newFixedThreadPool(int poolSize) ：产生一个 ExecutorService 对象，这个对象带有一个大小为 poolSize 的线程池，若任务数量大于 poolSize ，任务会被放在一个 queue 里顺序执行。

newCachedThreadPool( )：           产生一个 ExecutorService 对象，这个对象带有一个线程池，线程池的大小会根据需要自动调整，线程执行完任务后将会返回线程池，供执行下一次任务使用。

newSingleThreadExecutor( )：	   产生一个 ExecutorService 对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。

newSingleThreadScheduledExecutor ： 产生一个 ScheduledExecutorService 对象，这个对象的线程池大小为 1 ，若任务多于一个，任务将按照先后顺序执行。

newScheduledThreadPool(int poolSize)：产生一个 ScheduledExecutorService 对象，这个对象的线程池大小为 poolSize ，若任务数量大于 poolSize ，任务会在一个 queue 里等待执行。

newCachedThreadPool动态线程池

CachedThreadPool会创建一个缓存区，将初始化的线程缓存起来，如果线程有可用的，就使用之前创建好的线程，如果没有可用的，就会新创建线程。另外，终止并且从缓存中移除已有60秒未被使用的线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool1 {

    public static void main(String[] args){
        //创建一个动态的，可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们
        ExecutorService cached = Executors.newCachedThreadPool();

        //创建4个任务
        for (int i = 1; i < 5; i++) {
            int target = i;

            //向线程池中加入任务
            cached.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        try{
                            Thread.sleep(2000);
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            //e.printStackTrace();
                        }
                        //在执行任务时，打印一句话
                        System.out.println("第"+target+"个任务的第"+j+"执行");
                    }
                }
            });
        }
        cached.shutdown();
        System.out.println("主线程main()执行结束");
    }
}

执行结果：

主线程main()执行结束
第2个任务的第0执行
第1个任务的第0执行
第4个任务的第0执行
第3个任务的第0执行
第4个任务的第1执行
第1个任务的第1执行
第3个任务的第1执行
第2个任务的第1执行
第2个任务的第2执行
第3个任务的第2执行
第4个任务的第2执行
第1个任务的第2执行
第2个任务的第3执行
第1个任务的第3执行
第4个任务的第3执行
第3个任务的第3执行
第4个任务的第4执行
第3个任务的第4执行
第2个任务的第4执行
第1个任务的第4执行

Process finished with exit code 0

newFixedThreadPool

注意：创建一个固定大小的线程池。每次提交一个任务就会创建一个线程，直到创建的线程数量达到线程池的最大容量(数量)。线程池的大小一旦达到最大值就不会在创建新的线程。如果当所有线程都处于活动状态时，这时再有其他任务提交，他们将等待队列中直到有空闲的线程可用。如果任何线程由于执行过程中的故障而终止，将会有一个新线程将取代这个线程执行后续任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {

    public static void main(String[] args){
        //创建线程池，容量为3
        ExecutorService fixed = Executors.newFixedThreadPool(3);

        //主线程创建4个任务
        for (int i = 1; i < 5; i++) {
            int target = i;

            //向线程池中加入任务
            fixed.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        try{
                            Thread.sleep(2000);

                        } catch (InterruptedException e) {
//                            e.printStackTrace();i
                        }
                        //在执行任务时，打印一句话
                        System.out.println("第"+target+"个任务的第"+j+"执行");
                    }
                }
            });
        }
        cached.shutdown();
        System.out.println("主线程main()执行结束");
    }
}

执行结果：

主线程main()执行结束
第1个任务的第0执行
第3个任务的第0执行
第2个任务的第0执行        ---2s
第1个任务的第1执行
第3个任务的第1执行
第2个任务的第1执行        ---2s
第1个任务的第2执行
第2个任务的第2执行
第3个任务的第2执行        ---2s
第1个任务的第3执行
第2个任务的第3执行
第3个任务的第3执行        ---2s
第2个任务的第4执行 
第1个任务的第4执行
第3个任务的第4执行        ---2s
第4个任务的第0执行		---2s
第4个任务的第1执行		---2s
第4个任务的第2执行		---2s
第4个任务的第3执行		---2s
第4个任务的第4执行		---2s

Process finished with exit code 0

newScheduledThreadPool

此线程池支持定时以及周期性执行任务的需求。

import java.util.Calendar;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPool2 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1);
        //当前时间
        System.out.println(Calendar.getInstance().getTime());
        //5秒后执行任务
        schedulePool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Calendar.getInstance().getTime());
                System.out.println("线程一任务定点执行");
            }
        }, 5, TimeUnit.SECONDS);
        //5秒后执行任务，以后每2秒执行一次
        schedulePool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.print(Calendar.getInstance().getTime());

                System.out.println(" ---线程二任务周期执行！！");
            }
        }, 5, 2, TimeUnit.SECONDS);

    }
}

执行结果：

Sun Nov 29 09:05:44 CST 2020
Sun Nov 29 09:05:49 CST 2020
线程一任务定点执行
Sun Nov 29 09:05:49 CST 2020 ---线程二任务周期执行！！
Sun Nov 29 09:05:51 CST 2020 ---线程二任务周期执行！！
Sun Nov 29 09:05:53 CST 2020 ---线程二任务周期执行！！
Sun Nov 29 09:05:55 CST 2020 ---线程二任务周期执行！！
Sun Nov 29 09:05:57 CST 2020 ---线程二任务周期执行！！
Sun Nov 29 09:05:59 CST 2020 ---线程二任务周期执行！！
Sun Nov 29 09:06:01 CST 2020 ---线程二任务周期执行！！

Process finished with exit code -1

newSingleThreadExecutor

这个线程池中只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么就会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool3 {

    public static void main(String[] args){
        //得到的是一个单个的线程，这个线程会保证你的任务执行完成，如果当前线程意外终止，会创建一个新线程继续执行任务.
        ExecutorService single = Executors.newSingleThreadExecutor();

        //创建2个任务
        for (int i = 1; i < 3; i++) {
            int target = i;

            //向线程池中加入任务
            single.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 3; j++) {
                        try{
                            Thread.sleep(2000);
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
//                            e.printStackTrace();i
                        }
                        //在执行任务时，打印一句话
                        System.out.println("第"+target+"个任务的第"+j+"执行");
                    }
                }
            });
        }
        cached.shutdown();
        System.out.println("主线程main()执行结束");
    }
}

执行结果：

主线程main()执行结束		---2s
第1个任务的第0执行		---2s
第1个任务的第1执行		---2s
第1个任务的第2执行		---2s
第2个任务的第0执行		---2s
第2个任务的第1执行		---2s
第2个任务的第2执行		---2s

Process finished with exit code 0

ThreadPoolExecutor

阿里规范上说
(1)newFixedThreadPool 和SingleThreadPool
堆积的请求队列会造成内存增大,甚至OOM
(2)newCachedThreadPool 和newScheduledThreadPool
最大线程量 Integer.MAX_VALUE ,可能引发OOM
使用ThreadPoolExecutor可以更好地理解运行规则，规避资源耗尽的风险。

查看 Executors源码发现，内部都是由ThreadPoolExecutor实现，那么重点就放在ThreadPoolExecutor上
1.主要参数

• corePoolSize ：核心线程数量
  线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。
• maximumPoolSize : 最大线程数量
  一个任务被提交到线程池以后，首先会找有没有空闲存活线程，如果有则直接执行，如果没有则会缓存到工作队列（后面会介绍）中，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。
• keepAliveTime : 空闲线程最大存活时间
  一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定
• unit : 空闲线程存活时间单位
  keepAliveTime的时间计量单位
• workQueue : 用于保存等待执行的任务的阻塞队列
  新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

①ArrayBlockingQueue

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

②LinkedBlockingQuene

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

③SynchronousQuene

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

④PriorityBlockingQueue

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

• threadFactory : 用于创建线程的工厂
  创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等
• RejectedExecutionHandler : 饱和策略，就是当队列和线程池满了之后，采

当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：

①CallerRunsPolicy
该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

②AbortPolicy
该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

③DiscardPolicy
该策略下，直接丢弃任务，什么都不做。

④DiscardOldestPolicy
该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

线程池的状态

• Running状态：
  说明：能够接收新任务，以及对已添加的任务进行处理。
  切换：线程池的初始化状态是RUNNING。线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！
• Shutdown状态：
  说明：不接收新任务，但能处理已添加（缓存队列）的任务。
  切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
• Stop状态：
  说明：不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
  切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP
• Tidying状态：
  说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。
  切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
  当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
• Terminated状态：
  说明：线程池彻底终止，就变成TERMINATED状态。
  切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。