创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待。
源码
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
使用示例如下:
package com.test.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author :biws
* @date :Created in 2020/12/17 19:23
* @description:测试FixedThreadPool
*/
public class testThread1 {
public static void fixedThreadPool() {
// 创建 2 个数据级的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
// 创建任务
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
}
};
// 线程池执行任务(一次添加 4 个任务)
// 执行任务的方法有两种:submit 和 execute
threadPool.submit(runnable); // 执行方式 1:submit
threadPool.execute(runnable); // 执行方式 2:execute
threadPool.execute(runnable);
threadPool.execute(runnable);
}
public static void main(String[] args) {
fixedThreadPool();
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
后来我将测试数量提交到100,而线程池中处理线程得数量增加到4
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
执行结果
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
最开始,提交4个线程执行,之后的线程会在队列中排序等待被执行
如果觉得以上方法比较繁琐,还可以用更简单的使用方法,如下代码所示:
package com.test.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author :biws
* @date :Created in 2020/12/17 19:27
* @description:FixedThreadPool进阶写法
*/
public class testThreadG {
public static void fixedThreadPool() {
// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
/*
* 执行任务
* 为了个之前得进行统一,所以这里通过for循环,同样是提交4个执行*/
for(int i=1;i<=4;i++) {
threadPool.execute(() -> {
System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
});
}
}
public static void main(String[] args) {
fixedThreadPool();
}
}
创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程。
源码
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
参数详解:
corePoolSize = 0,
maximumPoolSize设置为Integer.MAX_VALUE,代表没有核心线程,非核心线程是无界的;keepAliveTime = 60L,空闲线程等待新任务的最长时间是60s;
用了阻塞队列SynchronousQueue,是一个不存储元素的阻塞队列
使用示例如下:
package com.test.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* @author :biws
* @date :Created in 2020/12/17 19:38
* @description:测试CachedThreadPool
*/
public class testThread2 {
public static void cachedThreadPool() {
// 创建线程池
ExecutorService threadPool = Executors.newCachedThreadPool();
// 执行任务
for (int i = 0; i < 10; i++) {
threadPool.execute(() -> {
System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
});
}
}
public static void main(String[] args) {
cachedThreadPool();
}
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
从上述结果可以看出,线程池创建了 10 个线程来执行相应的任务。
而如果我将sleep注释之后,再来看执行结果
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
我想这个结果一目了然吧,大家如果可以的话,可以把这个执行数据提升一下,然后再查看一下结果应该会更明显
创建单个线程数的线程池,它可以保证先进先出的执行顺序。为了能让大家看的更清楚,所以每个线程在执行得时候我都添加了他的时间
使用示例如下:
package com.test.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* @author :biws
* @date :Created in 2020/12/17 20:17
* @description:测试singleThreadExecutor
*/
public class testThread4 {
public static void singleThreadExecutor() {
// 创建线程池
ExecutorService threadPool = Executors.newSingleThreadExecutor();
// 执行任务
for (int i = 0; i < 10; i++) {
final int index = i;
threadPool.execute(() -> {
new Thread();
System.out.println(Thread.currentThread().getName()+"开始时间[" + new java.util.Date().getTime());
System.out.println(index + ":任务被执行");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName()+"结束时间[" + new java.util.Date().getTime());
});
}
}
public static void main(String[] args) {
singleThreadExecutor();
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
创建一个可以执行延迟任务的线程池。
源码
这个线程得源码有一点特殊,由两部分组成,第一部分
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
这里创建了ScheduledThreadPoolExecutor,
ScheduledThreadPoolExecutor继承自ThreadPoolExecutor ,主要用于给定 延时之后的运行任务或定期处理任务
第二部分
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
使用示例如下:
package com.test.thread;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author :biws
* @date :Created in 2020/12/17 20:43
* @description:测试ScheduledThreadPool
*/
public class testThread3 {
public static void scheduledThreadPool() {
// 创建线程池
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
// 添加定时执行任务(1s 后执行)
for(int i=0;i<4;i++){
final int index=i;
System.out.println(index+"添加任务,时间:" + new Date()+Thread.currentThread().getName());
threadPool.schedule(() -> {
System.out.println(index+"任务被执行,时间:" + new Date()+Thread.currentThread().getName());
/* try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}*/
}, 1, TimeUnit.SECONDS);
}
}
public static void main(String[] args) {
scheduledThreadPool();
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
创建一个单线程的可以执行延迟任务的线程池。
使用示例如下:
package com.test.thread;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author :biws
* @date :Created in 2020/12/17 20:54
* @description:测试SingleThreadScheduledExecutor
*/
public class testThread5 {
public static void SingleThreadScheduledExecutor() {
// 创建线程池
ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
// 添加定时执行任务(2s 后执行)
for (int i=0;i<4;i++) {
final int index=i;
System.out.println(index+"添加任务,时间:" + new Date());
threadPool.schedule(() -> {
System.out.println(index+"任务被执行,时间:" + new Date());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
}, 2, TimeUnit.SECONDS);
}
}
public static void main(String[] args) {
SingleThreadScheduledExecutor();
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
从上述结果可以看出,任务在 2 秒之后被执行了,符合我们的预期。
创建一个抢占式执行的线程池(任务执行顺序不确定)
注意:
此方法只有在 JDK 1.8+ 版本中才能使用。
使用示例如下:
public static void workStealingPool() {
// 创建线程池
ExecutorService threadPool = Executors.newWorkStealingPool();
// 执行任务
for (int i = 0; i < 10; i++) {
final int index = i;
threadPool.execute(() -> {
System.out.println(index + " 被执行,线程名:" + Thread.currentThread().getName());
});
}
// 确保任务执行完成
while (!threadPool.isTerminated()) {
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
最原始的创建线程池的方式,它包含了 7 个参数可供设置。
使用示例如下:
package com.test.thread;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author :biws
* @date :Created in 2020/12/17 21:07
* @description:测试ThreadPoolExecutor
*/
public class testThread7 {
public static void myThreadPoolExecutor() {
// 创建线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
// 执行任务
for (int i = 0; i < 10; i++) {
final int index = i;
threadPool.execute(() -> {
System.out.println(index + " 被执行,线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
public static void main(String[] args) {
myThreadPoolExecutor();
}
}
执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
就像我前面説的,ThreadPoolExecutor 是可以设置一些参数的,在我的代碼中,我只设置了这几个参数
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
在 源码 中是这样编写的
public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
7 个参数代表的含义如下:
corePoolSize
核心线程数,线程池中始终存活的线程数。
maximumPoolSize
最大线程数,线程池中允许的最大线程数,当线程池的任务队列满了之后可以创建的最大线程数。
keepAliveTime \ unit:
最大线程数可以存活的时间,当线程中没有任务执行时,最大线程就会销毁一部分,最终保持核心线程数量的线程。
单位是和参数 3 存活时间配合使用的,合在一起用于设定线程的存活时间
threadFactory
线程工厂,主要用来创建线程,默认为正常优先级、非守护线程。
workQueue
一个阻塞队列,用来存储线程池等待执行的任务,均为线程安全,它包含以下 7 种类型:
ArrayBlockingQueue:一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue:一个由链表结构组成的有界阻塞队列。
SynchronousQueue:一个不存储元素的阻塞队列,即直接提交给线程不保持它们。
PriorityBlockingQueue:一个支持优先级排序的无界阻塞队列。
DelayQueue:一个使用优先级队列实现的无界阻塞队列,只有在延迟期满时才能从中提取元素。
LinkedTransferQueue:一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似,还含有非阻塞方法。
LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列。
较常用的是 LinkedBlockingQueue 和 Synchronous,线程池的排队策略与 BlockingQueue 有关。
handler
拒绝策略,拒绝处理任务时的策略,系统提供了 4 种可选:
默认策略为 AbortPolicy。
代码演示
。。。。。
// 创建线程,线程的任务队列的长度为 1
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
new ThreadPoolExecutor.DiscardPolicy());
。。。。
//在Java种共有4种拒绝策略
/*
AbortPolicy:拒绝并抛出异常。
CallerRunsPolicy:使用当前调用的线程来执行此任务。
DiscardOldestPolicy:抛弃队列头部(最旧)的一个任务,并执行当前任务。
DiscardPolicy:忽略并抛弃当前任务。
*/</pre>
演示结果
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
我们创建了一个核心线程数和最大线程数都为 1 的线程池,并且给线程池的任务队列设置为 1,这样当我们有 2 个以上的任务时就会触发拒绝策略,
除了 Java 自身提供的 4 种拒绝策略之外,我们也可以自定义拒绝策略,示例代码如下:
。。。
// 创建线程,线程的任务队列的长度为 1
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
// 执行自定义拒绝策略的相关操作
System.out.println("我是自定义拒绝策略~");
}
});
。。。
程序的执行结果如下:
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
提交一个任务到线程池中,线程池的处理流程如下:
1、判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务。如果核心线程都在执行任务,则进入下个流程。
2、线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入下个流程。
3、判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务。如果已经满了,则交给饱和策略来处理这个任务。
90分钟10个手写案例,从源码底层给你讲解7种线程池创建方式
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。