之前写过JAVA中创建线程的三种方法及比较。这次来说说线程池。

　　JAVA中创建线程池主要有两类方法，一类是通过Executors工厂类提供的方法，该类提供了4种不同的线程池可供使用。另一类是通过ThreadPoolExecutor类进行自定义创建。

一、通过Executors类提供的方法。

1、newCachedThreadPool

2、newFixedThreadPool

3、newScheduledThreadPool

4、newSingleThreadExecutor

二、通过ThreadPoolExecutor类自定义。

三、五种方式的优劣比较

1、newCachedThreadPool

2、newFixedThreadPool

3、newScheduledThreadPool

4、newSingleThreadExecutor

一、通过Executors类提供的方法。

1、newCachedThreadPool

创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。

代码例子：

private static void createCachedThreadPool() {ExecutorService executorService = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {final int index = i;executorService.execute(() -> {// 获取线程名称,默认格式:pool-1-thread-1System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);// 等待2秒sleep(2000);});}}

效果：

　　因为初始线程池没有线程，而线程不足会不断新建线程，所以线程名都是不一样的。

2、newFixedThreadPool

创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。

代码例子：

private static void createFixedThreadPool() {ExecutorService executorService = Executors.newFixedThreadPool(3);for (int i = 0; i < 10; i++) {final int index = i;executorService.execute(() -> {// 获取线程名称,默认格式:pool-1-thread-1System.out.println(DateUtil.now() + " " +Thread.currentThread().getName() + " " + index);// 等待2秒sleep(2000);});}}

效果：

　　因为线程池大小是固定的，这里设置的是3个线程，所以线程名只有3个。因为线程不足会进入队列等待线程空闲，所以日志间隔2秒输出。

3、newScheduledThreadPool

创建一个周期性的线程池，支持定时及周期性执行任务。

代码例子：

private static void createScheduledThreadPool() {ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);System.out.println(DateUtil.now() + " 提交任务");for (int i = 0; i < 10; i++) {final int index = i;executorService.schedule(() -> {// 获取线程名称,默认格式:pool-1-thread-1System.out.println(DateUtil.now() + " " +Thread.currentThread().getName() + " " + index);// 等待2秒sleep(2000);}, 3, TimeUnit.SECONDS);}}

效果：

　　因为设置了延迟3秒，所以提交后3秒才开始执行任务。因为这里设置核心线程数为3个，而线程不足会进入队列等待线程空闲，所以日志间隔2秒输出。

注意：这里用的是ScheduledExecutorService类的schedule()方法，不是ExecutorService类的execute()方法。

4、newSingleThreadExecutor

创建一个单线程的线程池，可保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

代码例子：

private static void createSingleThreadPool() {ExecutorService executorService = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {final int index = i;executorService.execute(() -> {// 获取线程名称,默认格式:pool-1-thread-1System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);// 等待2秒sleep(2000);});}}

效果：

　　因为只有一个线程，所以线程名均相同，且是每隔2秒按顺序输出的。

二、通过ThreadPoolExecutor类自定义。

　　ThreadPoolExecutor类提供了4种构造方法，可根据需要来自定义一个线程池。

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {// 省略...}

1、共7个参数如下：

（1）corePoolSize：核心线程数，线程池中始终存活的线程数。

（2）maximumPoolSize: 最大线程数，线程池中允许的最大线程数。

（3）keepAliveTime: 存活时间，线程没有任务执行时最多保持多久时间会终止。

（4）unit: 单位，参数keepAliveTime的时间单位，7种可选。

参数	描述
TimeUnit.DAYS	天
TimeUnit.HOURS	小时
TimeUnit.MINUTES	分
TimeUnit.SECONDS	秒
TimeUnit.MILLISECONDS	毫秒
TimeUnit.MICROSECONDS	微妙
TimeUnit.NANOSECONDS	纳秒

（5）workQueue: 一个阻塞队列，用来存储等待执行的任务，均为线程安全，7种可选。

参数	描述
ArrayBlockingQueue	一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue	一个由链表结构组成的有界阻塞队列。
SynchronousQueue	一个不存储元素的阻塞队列，即直接提交给线程不保持它们。
PriorityBlockingQueue	一个支持优先级排序的无界阻塞队列。
DelayQueue	一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。
LinkedTransferQueue	一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似，还含有非阻塞方法。
LinkedBlockingDeque	一个由链表结构组成的双向阻塞队列。

较常用的是LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

（6）threadFactory: 线程工厂，主要用来创建线程，默及正常优先级、非守护线程。

（7）handler：拒绝策略，拒绝处理任务时的策略，4种可选，默认为AbortPolicy。

参数	描述
AbortPolicy	拒绝并抛出异常。
CallerRunsPolicy	重试提交当前的任务，即再次调用运行该任务的execute()方法。
DiscardOldestPolicy	抛弃队列头部（最旧）的一个任务，并执行当前任务。
DiscardPolicy	抛弃当前任务。

2、顺便说下线程池的执行规则如下：

（1）当线程数小于核心线程数时，创建线程。

（2）当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。

（3）当线程数大于等于核心线程数，且任务队列已满：

若线程数小于最大线程数，创建线程。

若线程数等于最大线程数，抛出异常，拒绝任务。

代码例子：

private static void createThreadPool() {ExecutorService executorService = new ThreadPoolExecutor(2, 10,1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(5, true),Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());for (int i = 0; i < 10; i++) {final int index = i;executorService.execute(() -> {// 获取线程名称,默认格式:pool-1-thread-1System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);// 等待2秒sleep(2000);});}}

效果：

　　因为核心线程数为2，队列大小为5，存活时间1分钟，所以流程是第0-1号任务来时，陆续创建2个线程，然后第2-6号任务来时，因为无线程可用，均进入了队列等待，第7-9号任务来时，没有空闲线程，队列也满了，所以陆续又创建了3个线程。所以你会发现7-9号任务反而是先执行的。又因为各任务只需要2秒，而线程存活时间有1分钟，所以线程进行了复用，所以总共只创建了5个线程。

三、五种方式的优劣比较

　　说是5种方式的比较，其实就是2种方式的比较，为什么这么说？因为Executors类提供的4种方式，其底层其实都是通过ThreadPoolExecutor类来实现的。换句话说，就是Executors类工厂通过参数的组合，组装出了上面提到的4种类型线程池供不同场景使用。我们可以通过查看Executors类的源码来看看：

1、newCachedThreadPool

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

因为SynchronousQueue队列不保持它们，直接提交给线程，相当于队列大小为0，而最大线程数为Integer.MAX_VALUE，所以线程不足时，会一直创建新线程，等到线程空闲时，又有60秒存活时间，从而实现了一个可缓存的线程池。

2、newFixedThreadPool

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

因为核心线程数与最大线程数相同，所以线程池的线程数是固定的，而且没有限制队列的大小，所以多余的任务均会被放到队列排队，从而实现一个固定大小，可控制并发数量的线程池。

3、newScheduledThreadPool

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

因为使用了延迟队列，只有在延迟期满时才能从中提取到元素，从而实现定时执行的线程池。而周期性执行是配合上层封装的其他类来实现的，可以看ScheduledExecutorService类的scheduleAtFixedRate方法。

4、newSingleThreadExecutor

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

因为核心线程数与最大线程数相同，均为1，所以线程池的线程数是固定的1个，而且没有限制队列的大小，所以多余的任务均会被放到队列排队，从而实现一个单线程按指定顺序执行的线程池。

虽然看上去Executors类的封装，可以简化我们的使用，但事实上，阿里代码规范《阿里巴巴Java开发手册》中明确不建议使用Executors类提供的这4种方法：

【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，
这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。Executors返回的线程池对象的弊端如下:FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE，
可能会堆积大量的请求，从而导致OOM。CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX_VALUE，
可能会创建大量的线程，从而导致OOM。

再回头看看上面的源码，确实如此。所以我们应该使用ThreadPoolExecutor类来创建线程池，根据自己需要的场景来创建一个合适的线程池。

本文来自博客园，作者：PC君，转载请注明原文链接：JAVA中创建线程池的五种方法及比较 - PC君 - 博客园

JAVA中创建线程池的五种方法及比较相关推荐

如何在JAVA中创建线程池
ExecutorService 今天小编要分享的是关于线程池, 想必接触到并发处理的朋友都有用到线程池, 当我们访问服务器的量达到服务器一定量的时候, 比如几百万几千万,很容易造成服务器崩掉, 如果使 ...
Java中实现线程安全的几种方法
我们知道Java有一个特性,多线程,它是一个同时运行多个线程的过程. 当多个线程处理相同的数据,并且我们的数据值发生变化时,这种情况不是线程安全的,我们会得到不一致的结果. 当一个线程已经在一个对象上 ...
关于线程池的五种实现方式，中软国际Java机试
在这里,还有创建一个只有单个线程的可以定时执行线程池(Executors.newSingleThreadScheduledExecutor())这些都是上面的线程池扩展开来了,不详细介绍了. 3 介绍 ...
线程池的五种状态及创建线程池的几种方式
上篇<Java线程的6种状态详解及创建线程的4种方式> 前言:我们都知道,线程是稀有资源,系统频繁创建会很大程度上影响服务器的使用效率,如果不加以限制,很容易就会把服务器资源耗尽.所以,我 ...
Java并发编程一线程池的五种状态
推荐:Java并发编程汇总 Java并发编程一线程池的五种状态原文地址 Java多线程线程池(4)–线程池的五种状态正文线程池的5种状态:Running.ShutDown.Stop.Tidyin ...
java创建线程池几种方式_java知识总结-创建线程池的6种方式
一.创建线程池的6种方式: Executors.newCachedThreadPool(); 创建一个可缓存线程池,应用中存在的线程数可以无限大 Executors.newFixedThreadPoo ...
JAVA中创建线程的三种方法及比较
JAVA中创建线程的方式有三种,各有优缺点,具体如下: 目录一.继承Thread类来创建线程二.实现Runnable接口来创建线程三.通过Callable和Future来创建线程四.三种方式创 ...
Java中创建线程的三种方式
Java中创建线程主要有三种方式: 一.继承Thread类创建线程类 (1)继承Thread类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务.因此把run()方法称为执行体. ...
线程及线程池的五种状态
线程的5种状态线程可以有如下5种状态:New .Runnable .Running .Blocked .Dead 状态之间的转换如图: 1.New (新创建) 当用new操作符创建一个线程时,如ne ...

JAVA中创建线程池的五种方法及比较

一、通过Executors类提供的方法。

1、newCachedThreadPool

2、newFixedThreadPool

3、newScheduledThreadPool

4、newSingleThreadExecutor

二、通过ThreadPoolExecutor类自定义。

三、五种方式的优劣比较

1、newCachedThreadPool

2、newFixedThreadPool

3、newScheduledThreadPool

4、newSingleThreadExecutor

JAVA中创建线程池的五种方法及比较相关推荐

最新文章

热门文章