五种线程池的对比与使用

2020年8月28日2020年8月28日 adminjavaLeave a Comment

newCachedThreadPool

1、重用之前的线程
2、适合执行许多短期异步任务的程序。
3、调用 execute() 将重用以前构造的线程
4、如果没有可用的线程，则创建一个新线程并添加到池中
5、默认为60s未使用就被终止和移除
6、长期闲置的池将会不消耗任何资源

例子：
public static void cache() {
    ExecutorService pool = Executors.newCachedThreadPool();
    long start = System.currentTimeMillis();
    pool.execute(() -> {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum = (int) Math.sqrt(i * i - 1 + i);
            System.out.println(sum);
        }
    });
    System.out.println("cache: " + (System.currentTimeMillis() - start));
}

源码：
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS, new SynchronousQueue());
}
通过源码可以看出底层调用的是ThreadPoolExecutor方法，传入一个同步的阻塞队列实现缓存。
ThreadPoolExecutor说明：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
}
通过源码可以看出，我们可以传入线程池的核心线程数(最小线程数)，最大线程数量，保持时间，时间单位，阻塞队列这些参数，最大线程数设置为jvm可用的cpu数量为最佳实践

newWorkStealingPool

1、获取当前可用的线程数量进行创建作为并行级别
2、使用ForkJoinPool

源码：
public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool (Runtime.getRuntime().availableProcessors(),
                    ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
}
通过源码可以看出底层调用的是ForkJoinPool线程池

ForkJoinPool说明：
public ForkJoinPool(int parallelism, ForkJoinWorkerThreadFactory factory, UncaughtExceptionHandler handler, boolean asyncMode) {
    this(checkParallelism(parallelism),
    checkFactory(factory),
    handler,
    asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
    "ForkJoinPool-" + nextPoolId() + "-worker-");
    checkPermission();
}
使用一个无限队列来保存需要执行的任务，可以传入线程的数量，不传入，则默认使用当前计算机中可用的cpu数量，使用分治法来解决问题，使用fork()和join()来进行调用

newSingleThreadExecutor

1、在任何情况下都不会有超过一个任务处于活动状态
2、与newFixedThreadPool(1)不同是不能重新配置加入线程，使用FinalizableDelegatedExecutorService进行包装
3、能保证执行顺序，先提交的先执行。
4、当线程执行中出现异常，去创建一个新的线程替换之

源码：
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
                 (new ThreadPoolExecutor(1, 1,
                  0L, TimeUnit.MILLISECONDS,
                  new LinkedBlockingQueue()));
}

newFixedThreadPool

1、创建重用固定数量线程的线程池，不能随时新建线程
2、当所有线程都处于活动状态时，如果提交了其他任务，他们将在队列中等待一个线程可用
3、线程会一直存在，直到调用shutdown

源码：
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                           0L, TimeUnit.MILLISECONDS,
                           new LinkedBlockingQueue());
}

newScheduledThreadPool

1、设定延迟时间，定期执行
2、空闲线程会进行保留

例子：
public static void main(String[] args) {
    ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
    for (int i = 0; i < 15; i = i + 5) {
        pool.schedule(() -> System.out.println("我被执行了，当前时间" + new Date()), i, TimeUnit.SECONDS);
    }
    pool.shutdown();
}
执行结果：
我被执行了，当前时间Fri Jan 12 11:20:41 CST 2018
我被执行了，当前时间Fri Jan 12 11:20:46 CST 2018
我被执行了，当前时间Fri Jan 12 11:20:51 CST 2018

源码：
return new ScheduledThreadPoolExecutor(corePoolSize);
通过源码可以看出底层调用的是一个ScheduledThreadPoolExecutor，然后传入线程数量

ScheduledThreadPoolExecutor说明：
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());
}
通过源码可以看出底层调用了ThreadPoolExecutor，维护了一个延迟队列，可以传入线程数量，传入延时的时间等参数。

为什么使用schedule()而不使用submit()或者execute()呢，下面通过源码来分析
public void execute(Runnable command) {
    schedule(command, 0, NANOSECONDS);
}
public Future submit(Runnable task) {
    return schedule(task, 0, NANOSECONDS);
}
通过源码可以发现这两个方法都是调用的schedule(),而且将延时时间设置为了0，所以想要实现延时操作，需要直接调用schedule()
下面我们再来分析一下submit()和execute()的以及shutdown()和shutdownNow()的区别
1、submit()，提交一个线程任务，可以接受回调函数的返回值吗，适用于需要处理返回着或者异常的业务场景
2、execute()，执行一个任务，没有返回值
3、shutdown()，表示不再接受新任务，但不会强行终止已经提交或者正在执行中的任务
4、shutdownNow()，对于尚未执行的任务全部取消，正在执行的任务全部发出interrupt()，停止执行

五种线程池的适应场景

1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于服务器负载较轻，执行很多短期异步任务。
2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于可以预测线程数量的业务中，或者服务器负载较重，对当前线程数量进行限制。
3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务，并且在任意时间点，不会有多个线程是活动的场景。
4、newScheduledThreadPool：可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。
5、newWorkStealingPool：创建一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行，适用于大耗时的操作，可以并行来执行

非原创，内容转至：https://www.jianshu.com/p/135c89001b61

发表回复取消回复