1、线程池简介
线程池(英语:thread pool):一种线程使用模式。线程过多会带来调度开销, 进而影响缓存局部性和整体性能。而线程池维护着多个线程,等待着监督管理 者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代 价。线程池不仅能够保证内核的充分利用,还能防止过分调度。
例子: 10 年前单核 CPU 电脑,假的多线程,像马戏团小丑玩多个球,CPU 需 要来回切换。 现在是多核电脑,多个线程各自跑在独立的 CPU 上,不用切换,效率高。
2、线程池的优势
线程池做的工作只要是控制运行的线程数量,处理过程中将任 务放入队列,然后在线程创建后启动这些任务,如果线程数量超过了最大数量, 超出数量的线程排队等候,等其他线程执行完毕,再从队列中取出任务来执行。
3、它的主要特点为:
a、
降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
b、
提高响应速度: 当任务到达时,任务可以不需要等待线程创建就能立即执行。
c、
提高线程的可管理性: 线程是稀缺资源,如果无限制的创建,不仅会销耗系统资 源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
4、线程池分类
a、一池一线程,也叫单线程池
b、一池N线程,也叫固定线程池,如设置4个线程池,他就总共4个线程
c、可扩容线程池,可根据情况扩容的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class poolDemo {
public static void main(String[] args) {
/*****************一池N线程**********************/
ExecutorService executorService1 = Executors.newFixedThreadPool(4);
try {
for (int i = 1; i <=10 ; i++) {
executorService1.execute(()->{
System.out.println(Thread.currentThread().getName()+"正在处理");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
executorService1.shutdown();
}
/*****************一池一线程**********************/
ExecutorService executorService2 = Executors.newSingleThreadExecutor();
try {
for (int i = 1; i <=10 ; i++) {
executorService2.execute(()->{
System.out.println(Thread.currentThread().getName()+"正在处理");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
executorService2.shutdown();
}
/*****************可扩容线程**********************/
ExecutorService executorService3 = Executors.newCachedThreadPool();
try {
for (int i = 1; i <=20 ; i++) {
executorService3.execute(()->{
System.out.println(Thread.currentThread().getName()+"正在处理");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
executorService3.shutdown();
}
}
}
5、线程池的七大核心参数及四个拒绝策略
请直接参考本人其他文章:线程池的七大核心参数大白话理解_九级代码狗的博客-CSDN博客
6、线程池执行流程
如下图所示,比如现在线程池核心线程数是2,最大线程是5,队列是3的线程池,那么线程执行execute()之后创建线程,1和2请求会优先处理,再来345请求会进入队列中,在来一个678的线程的话,由于队列已满,还没有达到最大线程数,还有三个线程可以创建,创建线程工厂会再次创建三个线程去处理,第9个来的时候,由于队列已满,线程已全部占用,就会被执行黄色框内的拒绝策略
7、为什么不让使用Executors去创建线程池,推荐使用自定义线程池
因为Executors创建的线程的队列长度是Interger.MAX_VALUE的,在实际工作中,这样的策略会导致请求大量的堆积,从而导致OOM(内存溢出),以下代码是自定义线程的示例
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class poolDemo2 {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory());
try {
for (int i = 1; i <=10 ; i++) {
threadPoolExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+"正在处理");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
threadPoolExecutor.shutdown();
}
}
}
8、Fork/Join合并分支
Fork:拆分的意思,如100拆分成1-50 51-100的结果,拆分过程可以使用二分查找
Join:把分拆任务的结果进行合并
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
public class forkjoin {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建拆分的类对象
join join=new join(0,100);
//创建合并分支池对象
ForkJoinPool pool=new ForkJoinPool();
//放入需要拆分合并的对象
ForkJoinTask<Integer> submit = pool.submit(join);
//获取最终合并结果
int sumNumber = submit.get();
System.out.println(sumNumber);
}
}
//使用二分查找 计算0-100的计算综合 规则是两两相加的差值不能超过10
class join extends RecursiveTask<Integer> {
//相差不大于数字
private final int value=10;
//开始数字
private int begin;
//结束数字
private int end;
//返回结果
private int result;
public join(int begin,int end){
this.begin=begin;
this.end=end;
}
@Override
protected Integer compute() {
//如果差值小于等于差值,则统计数据
if((end-begin)<=value){
for (int i = begin; i <=end ; i++) {
result=result+i;
}
}else{
//取中间值 100/2=50
int model=(begin+end)/2;
//拆分左边部分 0-50
join right=new join(begin,model);
//拆分右边部分 51-100
join left=new join(model+1,end);
//调用方法拆分
right.fork();
left.fork();
result=right.join()+left.join();
}
return result;
}
}
9、同步和异步
同步:比如你去张三的班级找张三,张三不在,那么你会一直在他的座位等他回来
异步:比如你去张三的班级找张三,张三不在,那么你会跟她们班级的同学说,等张三回来后告诉我一声,不需要等待
10、CompletableFuture的有返回值和无返回值的异步
具体描述请移步我兄弟的博客juc并发编程入门(一)_我是一只代码狗的博客-CSDN博客
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class CompletableFutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//没有返回值得异步
CompletableFuture.runAsync(()->{
System.out.println(Thread.currentThread().getName()+"进行了操作runAsync");
}).get();
//有返回值的异步
CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName()+"进行了操作supplyAsync");
return 1024;
}).whenComplete((t,e)->{
//t=返回值
System.out.println(t);
//e=异常信息,e=null是无异常的意思
System.out.println(e);
}).get();
}
}