前言
Java是天生就支持并发的语言,支持并发意味着多线程,线程的频繁创建在高并发及大数据量是非常消耗资源的,因此java提供了线程池。线程池好处 : 线程是稀缺资源,如果被无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,合理的使用线程池对线程进行统一分配、调优和监控,有以下好处:
- 降低资源消耗;
- 提高响应速度;
- 提高线程的可管理性;
在jdk1.5以前的版本中,线程池的使用是及其简陋的,但是在JDK1.5后,有了很大的改善。JDK1.5之后加入了java.util.concurrent包,java.util.concurrent包的加入给予开发人员开发并发程序以及解决并发问题很大的帮助。这篇文章主要介绍下并发包下的Executor接口,Executor接口虽然作为一个非常旧的接口(JDK1.5 2004年发布) Executor框架的最顶层实现是ThreadPoolExecutor类,Executors工厂类中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其实也只是ThreadPoolExecutor的构造函数参数不同而已。
通过传入不同的参数,就可以构造出适用于不同应用场景下的线程池,那么它的底层原理是怎样实现的呢,这篇就来介绍下ThreadPoolExecutor线程池的运行过程。corePoolSize: 核心池的大小。 当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;maximumPoolSize: 线程池最大线程数,它表示在线程池中最多能创建多少个线程; keepAliveTime: 表示线程没有任务执行时最多保持多久时间会终止;unit: 参数keepAliveTime的时间单位,有7种取值,在TimeUnit类中有7种静态属性;
提示:以下是本篇文章正文内容,下面案例可供参考
一、多线程相关问题
1) 什么是线程?
线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。比如,如果一个线程完成一个任务要100毫秒,那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持,它也是一个很好的卖点。
2) 线程和进程有什么区别?
线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的线程共享一片相同的内存空间。别把它和栈内存搞混,每个线程都拥有单独的栈内存用来存储本地数据。
3) 如何在Java中实现线程?
在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行,由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。
4) 用Runnable还是Thread?
这个问题是上题的后续,大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程,问题是,那个方法更好呢?什么情况下使用它?这个问题很容易回答,如果你知道Java不支持类的多重继承,但允许你调用多个接口。所以如果你要继承其他类,当然是调用Runnable接口好了。
6) Thread 类中的start() 和 run() 方法有什么区别?
这个问题经常被问到,但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程,而且start()内部调用了run()方法,这和直接调用run()方法的效果不一样。当你调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动,start()方法才会启动新线程。
7) Java中Runnable和Callable有什么不同?
Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了,Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回值和抛出异常,而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。
8) Java中CyclicBarrier 和 CountDownLatch有什么不同?
CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是,CountdownLatch 不能重新使用。
二、5种线程池的创建方法和作用
1.newCachedThreadPool
- 作用:创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们,并在需要时使用提供的 ThreadFactory 创建新线程。
- 特征:
- 线程池中数量没有固定,可达到最大值(Interger. MAX_VALUE)
- 线程池中的线程可进行缓存重复利用和回收(回收默认时间为1分钟)
- 当线程池中,没有可用线程,会重新创建一个线程
- 创建方式: Executors.newCachedThreadPool();
代码如下(示例):
package com.example.demo.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author liuxiansong
* 创建一个 Executors.newCachedThreadPool 可缓存线程池,应用中存在的线程数可以无限大
*/
public class NewCachedThreadPool {
public static void main(String[] args) {
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
System.out.println("创建一个 Executors.newCachedThreadPool 可缓存线程池,应用中存在的线程数可以无限大");
for (int i = 0; i <= 5; i++) {
newCachedThreadPool.execute(new ThreadPools(i));
}
}
}
class ThreadPools implements Runnable {
private Integer index;
public ThreadPools(Integer index) {
this.index = index;
}
@Override
public void run() {
/***
* 业务......省略
*/
try {
System.out.println("开始处理线程!!!" + index);
Thread.sleep(index * 100);
System.out.printf("线程标识: %s,线程名: %s \n", this.toString(), Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行如下(示例):
2.newFixedThreadPool
- 作用:创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程。在任意点,在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务,则在有可用线程之前,附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要)。在某个线程被显式地关闭之前,池中的线程将一直存在。
- 特征:
- 线程池中的线程处于一定的量,可以很好的控制线程的并发量
- 线程可以重复被使用,在显示关闭之前,都将一直存在
- 超出一定量的线程被提交时候需在队列中等待
- 创建方式:
- Executors.newFixedThreadPool(int nThreads);//nThreads为线程的数量
- Executors.newFixedThreadPool(int nThreads,ThreadFactory threadFactory);//nThreads为线程的数量,threadFactory创建线程的工厂方式
代码如下(示例):
package com.example.demo.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author liuxiansong
* 创建一个 Executors.newFixedThreadPool 可缓存线程池,应用中存在的线程数可以无限大
*/
public class NewFixedThreadPool {
public static void main(String[] args) {
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
System.out.println("创建一个 Executors.newFixedThreadPool 可缓存线程池,应用中存在的线程数可以无限大");
for (int i = 0; i <= 5; i++) {
newFixedThreadPool.submit(new ThreadPools(i));
}
newFixedThreadPool.shutdown();
}
}
class ThreadPools implements Runnable {
private Integer index;
public ThreadPools(Integer index) {
this.index = index;
}
@Override
public void run() {
/***
* 业务......省略
*/
try {
System.out.println("开始处理线程!!!" + index);
Thread.sleep(index * 100);
System.out.printf("线程标识: %s,线程名: %s \n", this.toString(), Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行如下(示例):
3.newSingleThreadExecutor
- 作用:创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。(注意,如果因为在关闭前的执行期间出现失败而终止了此单个线程,那么如果需要,一个新线程将代替它执行后续的任务)。可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同,可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
- 特征:
- 线程池中最多执行1个线程,之后提交的线程活动将会排在队列中以此执行
- 创建方式:
- Executors.newSingleThreadExecutor() ;
- Executors.newSingleThreadExecutor(ThreadFactory threadFactory);// threadFactory创建线程的工厂方式
代码如下(示例):
package com.example.demo.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author liuxiansong
* 创建一个 Executors.newSingleThreadExecutor 可缓存线程池,应用中存在的线程数可以无限大
*/
public class NewSingleThreadExecutor {
public static void main(String[] args) {
ExecutorService newFixedThreadPool = Executors.newSingleThreadExecutor();
System.out.println("创建一个 Executors.newSingleThreadExecutor 可缓存线程池,应用中存在的线程数可以无限大");
for (int i = 0; i <= 5; i++) {
newFixedThreadPool.execute(new ThreadPools(i));
}
newFixedThreadPool.shutdown();
}
}
class ThreadPools implements Runnable {
private Integer index;
public ThreadPools(Integer index) {
this.index = index;
}
@Override
public void run() {
/***
* 业务......省略
*/
try {
System.out.println("开始处理线程!!!" + index);
Thread.sleep(index * 100);
System.out.printf("线程标识: %s,线程名: %s \n", this.toString(), Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行如下(示例):
4.newScheduledThreadPool
- 作用: 创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
- 特征:
- 线程池中具有指定数量的线程,即便是空线程也将保留
- 可定时或者延迟执行线程活动
- 创建方式:
- Executors.newScheduledThreadPool(int corePoolSize);// corePoolSize线程的个数
- newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory);// corePoolSize线程的个数,threadFactory创建线程的工厂
代码如下(示例):
package com.example.demo.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author liuxiansong
* 创建一个 Executors.newScheduledThreadPool 可缓存线程池,应用中存在的线程数可以无限大
*/
public class NewScheduledThreadPool {
public static void main(String[] args) {
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
System.out.println("创建一个 Executors.newScheduledThreadPool 可缓存线程池,应用中存在的线程数可以无限大");
for (int i = 0; i <= 5; i++) {
newScheduledThreadPool.schedule(new ThreadPools(i), 1, TimeUnit.SECONDS);
// 10 秒后执行
newScheduledThreadPool.schedule(new ThreadPools(i), 10, TimeUnit.SECONDS);
}
newScheduledThreadPool.shutdown();
}
}
class ThreadPools implements Runnable {
private Integer index;
public ThreadPools(Integer index) {
this.index = index;
}
@Override
public void run() {
/***
* 业务......省略
*/
try {
System.out.println("开始处理线程!!!" + index);
Thread.sleep(index * 100);
System.out.printf("线程标识: %s,线程名: %s \n", this.toString(), Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行如下(示例):
5.newSingleThreadScheduledExecutor
- 作用: 创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
- 特征:
- 线程池中最多执行1个线程,之后提交的线程活动将会排在队列中以此执行
- 可定时或者延迟执行线程活动
- 创建方式:
- Executors.newSingleThreadScheduledExecutor() ;
- Executors.newSingleThreadScheduledExecutor(ThreadFactory threadFactory) ;//threadFactory创建线程的工厂
代码如下(示例):
package com.example.demo.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author liuxiansong
* 创建一个 Executors.newSingleThreadScheduledExecutor 可缓存线程池,应用中存在的线程数可以无限大
*/
public class NewSingleThreadScheduledExecutor {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
System.out.println("创建一个 Executors.newSingleThreadScheduledExecutor");
for (int i = 0; i <= 5; i++) {
scheduledExecutorService.schedule(new ThreadPools(i), 1, TimeUnit.SECONDS);
// 10 秒后执行
scheduledExecutorService.schedule(new ThreadPools(i), 10, TimeUnit.SECONDS);
}
scheduledExecutorService.shutdown();
}
}
class ThreadPools implements Runnable {
private Integer index;
public ThreadPools(Integer index) {
this.index = index;
}
@Override
public void run() {
/***
* 业务......省略
*/
try {
System.out.println("开始处理线程!!!" + index);
Thread.sleep(index * 100);
System.out.printf("线程标识: %s,线程名: %s \n", this.toString(), Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行如下(示例):
三、(推荐)ThreadPoolExecutor来创建线程池
1、源码分析 ,ThreadPoolExecutor
的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
构造函数参数
corePoolSize
核心线程数大小,当线程数 < corePoolSize ,会创建线程执行 runnablemaximumPoolSize
最大线程数, 当线程数 >= corePoolSize的时候,会把 runnable 放入 workQueue中keepAliveTime
保持存活时间,当线程数大于corePoolSize的空闲线程能保持的最大时间。unit
时间单位workQueue
保存任务的阻塞队列threadFactory
创建线程的工厂
2、ThreadPoolExecutor
实现原理
- 提交一个任务到线程池中,线程池的处理流程如下:
- 判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务。如果核心线程都在执行任务,则进入下个流程。
- 线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入下个流程。
- 判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务。如果已经满了,则交给饱和策略来处理这个任务。
- 采用ThreadPoolExecutor创建的优点:
- 可以实时获取线程池内线程的各种状态
- 可以动态调整线程池大小
代码如下(示例):
package com.example.demo.pool;
import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author liuxiansong888
*/
public class ThreadPool {
public static void main(String[] args) {
long currentTimeMillis = System.currentTimeMillis();
// 构造一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
5,
6,
3,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3)
);
for (int i = 1; i <= 10; i++) {
try {
String task = "task=" + i;
System.out.println("创建任务并提交到线程池中:" + task);
threadPool.execute(new ThreadPoolTask(task));
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
try {
//等待所有线程执行完毕当前任务。
threadPool.shutdown();
boolean loop = true;
do {
//等待所有线程执行完毕当前任务结束,等待2秒
loop = !threadPool.awaitTermination(2, TimeUnit.SECONDS);
} while (loop);
if (!loop) {
System.out.println("所有线程执行完毕");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("耗时:" + (System.currentTimeMillis() - currentTimeMillis));
}
}
}
class ThreadPoolTask implements Runnable, Serializable {
private Object attachData;
ThreadPoolTask(Object tasks) {
this.attachData = tasks;
}
@Override
public void run() {
try {
System.out.println("开始执行任务:" + attachData + "任务,使用的线程池,线程名称:" + Thread.currentThread().getName());
} catch (Exception e) {
e.printStackTrace();
}
attachData = null;
}
}
运行如下(示例):
参考文章:
https://blog.csdn.net/weixin_35982425/article/details/82704987
https://www.cnblogs.com/2549372994jing/p/11452648.html
https://www.toutiao.com/i6490300018983961102/
总结
提示:现在做开发的同学,越来越多的人在创建线程池用ThreadPoolExecutor,而不是用JDK提供的五种方法来创建。
阿里编码规约 :线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。 说明:Executors返回的线程池对象的弊端如下:
1)FixedThreadPool和SingleThreadPool:
允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
2)CachedThreadPool:
允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。
Positive example 1:
//org.apache.commons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
Positive example 2:
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();
//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 200,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown
Positive example 3:
<bean id="userThreadPool"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="queueCapacity" value="2000" />
<property name="threadFactory" value= threadFactory />
<property name="rejectedExecutionHandler">
<ref local="rejectedExecutionHandler" />
</property>
</bean>
//in code
userThreadPool.execute(thread);