黑马程序员技术交流社区

标题: 对 Java 四种线程池的简要分析 [打印本页]

---

作者: 长沙-小知姐姐    时间: 2020-4-3 11:37
标题: 对 Java 四种线程池的简要分析

1 谈谈线程池

在之前，我们在需要使用线程的时候就去创建一个线程，可谓是非常简便了。但是，当并发的线程数量多了之后，频繁创建线程会令系统的效率大大下降。

那有没有办法可以令我们复用线程？线程在执行完一个任务之后，不会销毁，进而执行其他的任务呢？

事实上，我们可以通过线程池实现相应的功能。在 Java 中，线程池的顶级接口是 Executor，但它并不是线程池的具体实现，真正的线程池实现类为 ThreadPoolExecutor。

我们可以向线程池中传递任务以获得执行，可传递的任务有以下两种，分别是通过 Runnable 实现的任务与通过 Callable 实现的任务，这两者之间的区别为 Runnable 没有返回值但 Callable 有返回值。

2 四种线程池

在 Java 提供了四种线程池的具体实现，分别如下：

newCachedThreadPool：创建一个可缓存线程池
newFixedThreadPool：创建一个定长线程池
newScheduledThreadPool：创建一个定长线程池
newSingleThreadExecutor：创建一个单线程化的线程池
下面对这四种线程池进行简单介绍。

newCachedThreadPool
newCachedThreadPool 是一个可缓存线程池。当调用 execute 方法时，会重用以前构造的线程。该线程池的线程数量并不固定，且线程数量的最大值为 Integer.MAX_VALUE。线程池中的空闲线程有超时限制，这个时间为60秒，超过60秒闲置线程就会被回收。

该线程池适合执行大量耗时较少的任务，当线程池处于闲置状态时，线程池中的所有线程都会因为超时从而被回收。

package test;

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

public class ThreadPoolTest {

        public static void main(String[] args) {
                ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
               
                for(int i = 0;i < 10;i++) {
                        int index = i;
                        try {
                                Thread.sleep(100);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                       
                        cachedThreadPool.execute(() -> System.out.println("第" + index + "个任务，当前执行任务的线程为：" + Thread.currentThread().getName()));
                }
        }
}

结果如下：



我们可以发现，事实上执行我们任务的都是同一个线程，这是因为当我们执行下一个任务时，上一个任务已经执行完成，可以复用上一个任务使用的线程，不需要新建线程。

newFixedThreadPool
newFixedThreadPool 是一个定长线程池，该线程池可以指定工作线程数量，每当我们提交一个任务时，就会创建一个工作线程，且当工作线程处于空闲状态时并不会被回收。当工作线程的数量超过最大值时，会将提交的任务存放进没有大小限制的队列中。

newFixedThreadPool 只有核心线程，且这些核心线程并不会被回收，故其能够快速响应外界请求。

package test;

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

public class ThreadPoolTest {

        public static void main(String[] args) {
                //最大线程个数为3
                ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
               
                for(int i = 0;i < 10;i++) {
                        int index = i;
                        fixedThreadPool.execute(() -> {
                                System.out.println("第" + index + "个任务，当前执行任务的线程为：" + Thread.currentThread().getName());
                                try {
                                        Thread.sleep(100);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        });
                }
        }
}

结果如下：



我们可以发现，由于我们设置的最大线程为3，故当线程池的工作线程等于3个时，即使有新任务进来且无空闲线程，也不会新建线程，而是会将其存放入队列中等待工作线程进行消费。

newScheduledThreadPool
newScheduledThreadPool 是一个定长线程池，它的核心线程数量是固定的，而非核心线程数是没有限制的，且当非核心线程闲置时会被回收。

newScheduledThreadPool 可以延迟运行任务或定时执行任务，适合于执行定时任务或执行周期性任务。

package test;

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

public class ThreadPoolTest {

        public static void main(String[] args) {
                ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
                System.out.println("开始时间" + System.currentTimeMillis());
                scheduledThreadPool.schedule(() -> System.out.println("执行任务的时间" + System.currentTimeMillis()),5,TimeUnit.SECONDS);
        }
}

结果如下：



newScheduledThreadPool 确实起到延时执行任务的作用。

newSingleThreadExecutor
newSingleThreadExecutor 是一个单线程化的线程池。该线程池内部只有一个核心线程，任务会存放进一个无界队列中让该线程顺序执行。newSingleThreadExecutor 的特点就是确保所有任务在同一线程内顺序执行。

package test;

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

public class ThreadPoolTest {

        public static void main(String[] args) {
                ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
                for(int i = 0;i < 10;i++) {
                        int index = i;
                        singleThreadExecutor.execute(() -> System.out.println("第" + index + "个任务被执行"));
                }
        }
}

结果如下：



可见 newSingleThreadExecutor 保证了上述线程的顺序化执行。

3 线程池的原理

看到这里，可能有的读者会非常疑惑。咦，博主，你之前不是说真正的线程池实现类为 ThreadPoolExecutor 吗，我看你介绍了四种线程池，怎么就没提到 ThreadPoolExecutor 呢？别急，且听我慢慢解释。

我们以 newCachedThreadPool 为例子进行讲解，当你执行下面这行代码时

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

其实真正执行的是 ThreadPoolExecutor 的构造方法，换言之，四种线程池底层都是通过 ThreadPoolExecutor 来进行初始化的。

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

其它三种线程池的实现如下：

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

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

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

    //ScheduledThreadPoolExecutor继承了ThreadPoolExecutor且实现了ScheduledExecutorService接口
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

那我们再来看看在 newCachedThreadPool 中调用的 ThreadPoolExecutor 的构造函数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
}

它真正调用的是这个构造函数

public ThreadPoolExecutor(int corePoolSize,  
                              int maximumPoolSize,  
                              long keepAliveTime,  
                              TimeUnit unit,  
                              BlockingQueue<Runnable> workQueue,  
                              ThreadFactory threadFactory,  
                              RejectedExecutionHandler handler)

每个参数的具体含义如下：

corePoolSize：核心池大小，当线程池的线程数量超过了这个值，会将新的任务放置在等待队列中
maximumPoolSize：线程池最大线程数量，即线程池能创建的最大线程数
keepAlivertime：当活跃线程数大于核心线程数时，多余线程的最大存活时间
unit：存活时间的单位
workQueue：一个存放任务的阻塞队列
threadFactory：线程工厂，用来创建线程
handler：当线程池的任务缓存队列已满并且线程池中的线程数目达到 maximumPoolSize 且仍有任务到来时执行的任务拒绝策略

4 线程池的优点

线程池可以重用线程，以避免线程的频繁创建和销毁带来的性能开销
可以有效控制线程池的并发数，有效避免大量的线程争夺 CPU 资源而造成堵塞
线程池可以对线程进行管理，例如可以提供定时、定期、单线程、并发数控制等功能
————————————————

原文链接：「Geffin」https://blog.csdn.net/Geffin/article/details/105231333

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2