---

线程池参数

	直接new ThreadPoolExecutor()对象，并且手动的指定对应的参数
     corePoolSize:线程池的核心线程数量 线程池创建出来后就会 new Thread() 5个
     maximumPoolSize:最大的线程数量，线程池支持的最大的线程数
     keepAliveTime:存活时间，当线程数大于核心线程，空闲的线程的存活时间 8-5=3
     unit:存活时间的单位
     BlockingQueue<Runnable> workQueue:阻塞队列 当线程数超过了核心线程数据，那么新的请求到来的时候会加入到阻塞的队列中
     new LinkedBlockingQueue<>() 默认队列的长度是 Integer.MAX 那这个就太大了，所以我们需要指定队列的长度
     threadFactory:创建线程的工厂对象
     RejectedExecutionHandler handler:当线程数大于最大线程数的时候会执行的淘汰策略
1
2
3
4
5
6
7
8
9

ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5
                , 100
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(10000)
                , Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.AbortPolicy()
        );
1
2
3
4
5
6
7
8

线程池执行流程

• 首先根据 corePoolSIze创建工作线程
• 当并发量超过核心线程数，将多余的任务放如任务队列
• 如果任务队列满了，判断并发量是否超过最大线程数量，如果没有创建新的线程执行任务；
• 当任务处理完成，超过核心线程数量的线程会根据TimeUtil，过期销毁
• 如果启动新线程后仍处理不了任务，多余的任务根据拒绝策略进行其他操作

JDK中提供的几种线程池

1. newCachedThreadPool
   带有缓存的线程池，会在需要线程资源的时候进行创建，注意这里的最大线程数是Integer.MAX_VALUE
   线程休眠时间为60s，超过时间会进行销毁。
   一般用于执行短生命周期的异步任务

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

2. newSingleThreadExecutor
   单例线程池，线程池中时刻保证工作线程为1， 串行执行任务。
   不同于fixedPool， 他保证返回的Executor不会创建额外的线程

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
   return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}
1
2
3
4
5
6
7

3. newScheduledThreadPool
   具有定时任务的线程池，能够在延迟一定时间或定期执行任务。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
  return new ScheduledThreadPoolExecutor(corePoolSize);
}


// new ScheduledThreadPoolExecute()
// 创建一个延迟队列
public ScheduledThreadPoolExecutor(int corePoolSize,
                               ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue(), threadFactory);
}
1
2
3
4
5
6
7
8
9
10
11
12