java多线程-7（线程池）

java线程池

1. 什么是线程池

   线程池是一个存储线程的容器。使用线程池后，会创建若干个可执行的线程放入池中。需要使用线程的时候直接从池中获取而不用自己创建。线程使用完后又回到池中，等待下一次任务。

2. 为什么要使用线程池

   • 避免频繁的创建和销毁线程
   • 使用池达到线程的复用
   • 线程的创建于执行完全分开，方便维护。还可以根据项目灵活地控制并发的数目

3. java默认的几种线程池

   • newFixedThreadPool

   创建一个核心线程数量固定，没有非核心线程，队列容量无界的线程池。传入的参数即是核心线程数量，核心线程数量也是最大线程数量。没有空闲线程，所以keepAliveTime为0。

   public static ExecutorService newFixedThreadPool(int nThreads) { 
       return new ThreadPoolExecutor(nThreads, nThreads,
                                     0L, TimeUnit.MILLISECONDS,
                                     new LinkedBlockingQueue<Runnable>());
   }
   

   • newCachedThreadPool

   创建一个没有核心线程，只有非核心线程，队列为同步队列的线程池。非核心线程即为最大线程数量，最大值为nteger.MAX_VALUE。处理任务时，若池中有空闲线程，则用空闲线程执行任务，若没有，则创建线程。池中的空闲线程超过60秒，将被销毁。若线程数量达到最大值，没有服务器能够继续工作，则OOM。

   public static ExecutorService newCachedThreadPool() {
       return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                     60L, TimeUnit.SECONDS,
                                     new SynchronousQueue<Runnable>());
   }
   

   • newSingleThreadExecutor

   创建一个单线程，队列容量无界的线程池，线程串行执行所有的任务。核心线程数为1，核心线程即为最大线程数。当线程因为异常销毁时，则会创建一个新的线程继续执行后续的任务。相对于newFixedThreadPool(1)来说，newSingleThreadExecutor创建的线程池线程数量不可修改的，而后者是可以修改的。

   public static ExecutorService newSingleThreadExecutor() {
       return new FinalizableDelegatedExecutorService
           (new ThreadPoolExecutor(1, 1,
                                   0L, TimeUnit.MILLISECONDS,
                                   new LinkedBlockingQueue<Runnable>()));
   }
   

   • newScheduledThreadPool

   创建一个定时执行任务的线程池，核心线程数由参数决定，最大线程数为Integer.MAX_VALUE，存在OOM风险。改线程池不会回收线程。

   public ScheduledThreadPoolExecutor(int corePoolSize) {
       super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
             new DelayedWorkQueue());
   }
   

   • newWorkStealingPool

   JDK8新增的一种线程池，拥有多个任务队列。创建当前可用CPU数量的线程来并行执行任务。

   public static ExecutorService newWorkStealingPool(int parallelism) {
       return new ForkJoinPool
           (parallelism,
            ForkJoinPool.defaultForkJoinWorkerThreadFactory,
            null, true);
   }
   

4. 线程池的7大参数

   • corePoolSize：核心线程数量，不会被销毁

   • maximumPoolSize：最大线程数量

   • keepAliveTime ：如果一个线程处于空闲状态，并且当前线程数量超过corePoolSize，那么在keepAliveTime 这个指定的时间后就会被销毁。

   • unit: keepAliveTime的计量单位

   • workQueue：工作队列。当有新任务时，会放在工作队列中，有空闲线程了再从队列中取出来执行。

     1. ArrayBlockingQueue：基于数组的有界阻塞队列。按FIFO排序
     2. LinkedBlockingQuene：基于链表的无界阻塞队列，按FIFO排序
     3. SynchronousQuene：一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。
     4. PriorityBlockingQueue：具有优先级的无界阻塞队列，可通过Comparator参数设置优先级。

   • threadFactory：线程工厂。创建线程时使用的工厂，可以用来设置线程名与是否为守护线程等。

   • handler：拒绝策略，当工作队列中任务已满，且线程数量达到最大，此时如果有新任务，就会采取拒绝策略。默认为AbortPolicy

     • AbortPolicy：丢弃任务，抛出RejectedExecutionException异常
     • CallerRunsPolicy：使用调用者的线程来运行任务。
     • DiscardOldestPolicy：丢弃最早进入队列的任务，并尝试将当前任务加入队列。
     • Discard Policy：直接丢弃任务，什么都不做。

5. 线程池的简单工作流程

6. 为什么不推荐使用默认的线程池

   阿里巴巴开发手册上写到：
   

7. 自定义线程池实例

public class Demo1{
    public static void main(String[] args) {
        ExecutorService executorService=new ThreadPoolExecutor(
                                                    2, //corePoolSize
                                                    5, //maximumPoolSize
                                                    3, //keepAliveTime 
                                                TimeUnit.SECONDS, //unit
                            new LinkedBlockingDeque<>(3), //workQueue
                            Executors.defaultThreadFactory(), //threadFactory
                            new ThreadPoolExecutor.DiscardOldestPolicy() //handler
                );
        try {
            for (int i = 1; i <=10; i++) {
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"进来了");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}