java线程池

什么是线程池

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

为什么要使用线程池

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

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);
}

线程池的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：直接丢弃任务，什么都不做。

线程池的简单工作流程

java什么时候用线程池什么时候不用 java线程池默认多少个线程_java

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

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

自定义线程池实例

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();
        }
    }
}