线程池
8.线程池用过吗? ThreadPoolExecutor谈谈你的理解?
9.线程池用过吗?生产上你如何设置合理参数
1、Callable
- 为何出现，还是 想要开线程分开计算，最后在把结果合并。
- 类似于：juc的：ForkJoin
简单使用
public class CallableDemo implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("你好");
return "hello";
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//=====================运行1==========================
ExecutorService es = Executors.newFixedThreadPool(1);
//提交运行
Future<String> submit = es.submit(new CallableDemo());
//获取结果
String r1 = submit.get();
System.out.println(r1);
es.shutdown();//不关闭，主线程不结束
//=====================运行2==========================
//将来的任务
FutureTask<String> f = new FutureTask(new CallableDemo());
//这次不会走call()，会复用。如果非要执行 请在此创建FutureTask
//多个线程抢 FutureTask，只算一次。
new Thread(f, "AAA").start();
new Thread(f, "BBB").start();
//如果算完了。 为true，取反为false，跳出循环。
while (!f.isDone()) {
//如果没算完。就一直自旋。
}
//建议放到最后。如果没有计算完成就要去强求，会导致堵塞
System.out.println(f.get());
//=====================运行3==========================
FutureTask<String> f = new FutureTask(new CallableDemo());
f.run();
//获取结果
System.out.println(f.get());
}
}
FutureTask
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
//适配器模式
public class FutureTask<V> implements RunnableFuture<V> {
//构造 注入：Callable，自己又实现了 Runnable
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
}
}
public interface RunnableScheduledFuture<V> extends RunnableFuture<V>, ScheduledFuture<V> {
boolean isPeriodic();
}
2、线程池 ThreadPoolExecutor
System.out.println(Runtime.getRuntime().availableProcessors());
优势
为什么用线程池，优势
线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务.
如果线程数量超过了最
大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。
他的主要特点为:线程复用;控制最大并发数;管理线程。
第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二:提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
第三:提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控
简介
Java中的线程池是通过Executor框架实现的，该框架中用到了
Executor 接口
-
ExecutorService 接口
-
AbstractExecutorService 抽象类
- ThreadPoolExecutor 类，线程池的底层，ThreadPool Executor
-
ScheduledExecutorService 接口
- ScheduledThreadPoolExecutor 类，也继承了：ThreadPoolExecutor
-
Executors 是工具类
execute
英
/ˈeksɪkjuːt/
v.
执行，实施；处决；完成，表演（高难度动作）；制作（艺术作品）；（计算机）执行指令（或程序）
//Array Arrays
//collection collections
//Executor,Executors
List<String> list = Arrays.asList("1", "1", "2");
3、3种常用方法
- java8 一共6种，最常用3种。
Executors.newFixedThreadPool(int) //固定的。执行长期的任务，性能好很多
Executors.newSingleThreadExecutor() //单的。一个任务一个任务执行的场景
Executors.newCachedThreadPool() //可扩容，带缓存的。适用:执行很多短期异步的小程序或者负载较轻的服务器
//使用处理器并行的
Executors.newWorkStealingPool(int) //java8新增,使用目前机器上可用的处理器作为它的并行级别
//单个有调度，多个有调度的
ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
Executors.newScheduledThreadPool()//调度的，如：池子里面的请求，每2秒执行一次。
stealing
英
/ˈstiːlɪŋ
n.
偷窃；贼赃；偷垒（棒球比赛中的犯规行为）
adj.
有偷窃行为的
steal
英
/stiːl
v.
偷窃，盗窃；剽窃，窃取（观点）；悄悄地移动；（在棒球比赛中）偷（垒）；
n.
极廉价的物品，低价；（尤指篮球比赛中的）断球；
public interface ExecutorService extends Executor {
}
- 第4种获得/使用java多线程的方式，线程池
fix
英
/fɪks/
v.
修理，维修；确定（时间、地点、价格等）；安排，组织；处理，解决（问题等）；固定，安装；盯住，凝视；
n.
（尤指简单、暂时的）解决方法；<非正式>受操纵的事，勾当；
固定数量的
ExecutorService e2 = Executors.newFixedThreadPool(5);
//Executors
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
//ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
主要特点如下:
1创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
2newFixedThreadPoo创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue;
单一的
ExecutorService e3 = Executors.newSingleThreadExecutor();
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
主要特点如下:
1创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。2 newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，它使用的LinkedBlockingQueue
缓冲的
ExecutorService e = Executors.newCachedThreadPool();
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
主要特点如下:
1创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。2 newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程
- SynchronousQueue 不存储元素的阻塞队列，也即单个元素的队列。同步队列。
4、7个参数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
}
今日当值窗口
1.corePoolSize:线程池中的常驻核心线程数
-
银行的：今日当值窗口。
-
1在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程
2当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中;
最大窗口
2.maximumPoolSize:线程池能够容纳同时执行的最大线程数，此值必须大于等于1
- 网点 能支持的最大开放 物理窗口的上限。比如：一共5个窗口。2个当值的，3个后备的。
keepAliveTime 加班窗口存活时间 和 单位
3.keepAliveTime:多余的空闲线程的存活时间。
当前线程池数量超过corePoolSize时 扩容，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止
-
3,4,5 放入了 候客区（也满了）， 6 7 8，也来了。
-
此时：另外的3个窗口（加班窗口），全部打开（就是达到 最大物理窗口 5）
-
6 7 8，去抢占，还是去 候客区等候呢？
- 6 7 8 直接加塞抢占，加班窗口。占满。
-
如果：候客区，加班窗口 都满了，又过来，将进入 饱和拒绝策略。
-
业务量很少时，加班窗口在这个约定的时间关闭（缩容）
4.unit: keepAliveTime的单位。
阻塞队列 候客区
5.workQueue:任务队列，被提交但尚未被执行的任务。
- 阻塞队列，候客区。3 4 5发现 核心线程用满了，进入这里等待。
线程工厂
6.threadFactory:表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
- 默认->银行网点的logo/工作人员的制服/胸卡…，就是 约定成俗的 东西。
- 银行网点的标配，制服，胸卡都一样。
拒绝策略
7.handler:拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数( maximumPoolSize）时如何来
总结
- 当值窗口，满了：进入等候区 阻塞队列。
- 当值窗口满了，阻塞队列满了，进行扩容（加班窗口）
- 都满了，业务依然疯狂的上涨，进入 拒绝策略。
- 业务量 下降，加班窗口 会慢慢的缩容。最终缩容到 核心数（当值窗口）
- 加班窗口没人办业务，过了存活时间消失。
- 先去 核心窗口办理业务 1 2顾客。
- 核心满了，来的人去候客区等待。 3 4 5 顾客。
- 候客区满了，开启扩容。启用加班窗口。此时加班窗口+ 核心窗口为 最大窗口。
- 5 6 7 顾客，占用了 这3个加班窗口
- 核心满了，候客区满了，加班窗口满了，进入拒绝策略。
- 就是：核心为2，加班窗口为3，构成了最大5
- 阻塞队列候客区 为3，只能同时来8个人，来9个话，就进入 拒绝策略。
- 4种拒绝策略怎么配置。
- 加班窗口存活时间，比如 5秒内，没有在收到其他请求，关闭。
再次整理：
- 核心数有没有满？满了 将任务存储在阻塞队列
- 阻塞队列是否满了？满了创建 线程执行任务（加班窗口打开）
- 阻塞队列+最大窗口有没有满？满了 按照拒绝策略处理。
- RejectedExecutionHandler
- AbortPolicy 默认 拒绝策略。中断报错。
- java.util.concurrent.RejectedExecutionException
- DiscardPolicy 扔掉
- CallerRunsPolicy 退回调用者
- DiscardOldestPolicy 扔阻塞队列（候客区）等待最久的
- AbortPolicy 默认 拒绝策略。中断报错。
policy
英
/ˈpɒləsi/
n.
政策，方针；(处事) 原则，策略；保险单
abort
英
/əˈbɔːt/
v.
（使）流产，堕（胎）；（由于问题或故障）中止，使夭折；（
n.
<非正式>（飞行、航天任务或其他事业的）中断，取消
discard
英
/dɪˈskɑːd/
v.
扔掉，弃置；打出（无用的牌），垫（牌）
n.
被抛弃物；（纸牌游戏中）垫出的牌
底层工作原理 老师整理
1．在创建了线程池后，等待提交过来的任务请求。
2.当调用execute()方法添加一个请求任务时，线程池会做如下判断:
2.1 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务;
2.2如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列;
2.3如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务;
2.4 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
3.当一个线程完成任务时，它会从队列中取下一个任务来执行。
4.当一个线程无事可做超过一定的时间（keepAliveTime）时，线程池会判断:
如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。
- 可知：1 2 是核心窗口。 3 4 5 是加班窗口。最终留2个，不确定是 哪两个。测试过。
所以线程池的所有任务完成后它最终会收统到corePoolSize的大小。
5、拒绝策略
线程池的拒绝策略你谈谈
你在工作中是如何使用线程池的，是否自定义过线程池使用
合理配置线程池你是如何考虑的?
是什么
等待队列也已经排满了，再也塞不下新任务了同时，
线程池中的max线程也达到了，无法继续为新任务服务。
这时候我们就需要拒绝策略机制合理的处理这个问题。
四大拒绝策略
抛异常 AbortPolicy(默认):
- 直接抛出RejectedExecutionException异常阻止系统正常运行。
打回调用方 CallerRunsPolicy:
- "调用者运行"一种调节机制，该策略既不会抛弃任务,
- 而是将某些任务回退到调用者,从而降低新任务的流量。
丢弃阻塞队列最久 DiscardoldestPolicy:
- 抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。
直接丢弃 DiscardPolicy:
- 直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案。
JDK内置的拒绝策略
- 以上内置拒绝策略均实现了RejectedExecutionHandler接口
我在工作用哪个？
你在工作中单一的/固定数的/可变的三种创建线程池的方法，你用那个多﹖超级大坑
- 看了源码，我哪个也不用，因为 拒绝策略是默认的
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
答案是一个都不用，我们生产上只能使用自定义的Executors 中JDK已经给你提供了，为什么不用?Z
阿里巴巴要求
3．【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
说明:使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
4.【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明:Executors返回的线程池对象的弊端如下:
-
- FixedThreadPool和 SingleThreadPool:
-
允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
-
加班窗口回收的特别快，阻塞队列，超级大（候客区21亿），Integer.MAX_VALUE
- 都 OOM了，也不会触发 拒绝策略 这两都一样。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
-
- CachedThreadPool和scheduledThreadPool:
- 允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM.
- newCachedThreadPool 最大窗口（21亿）为 Integer.MAX_VALUE，可以无限开：加班窗口了。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
- 总结：
- 如果忽然来大量请求，再强的服务器，也会 OOM
6、自定义线程池
你在工作中是如何使用线程池的，是否自定义过线程池使用
代码
-
最大线程数为：max + 阻塞队列数
-
ThreadPoolExecutor.AbortPolicy() 拒绝后报错：java.util.concurrent.RejectedExecutionException
-
ThreadPoolExecutor.CallerRunsPolicy() 出现：main服务顾客9
-
new ThreadPoolExecutor.DiscardOldestPolicy() 阻塞队列里3，是最先进入的，会被丢弃
-
new ThreadPoolExecutor.DiscardPolicy() 最后一个来的，会被丢弃
ExecutorService p = new ThreadPoolExecutor(
2, 5, //核心2，最大5
100L, TimeUnit.SECONDS,//100秒内，线程空闲，当前线程数 > 核心数，缩容。
new LinkedBlockingDeque<>(3), //候客区阻塞队列为3，就是达到8个，触发拒绝策略。
Executors.defaultThreadFactory(), //默认的工厂
new ThreadPoolExecutor.AbortPolicy() //报错的拒绝策略。
);
for (int i = 1; i <= 9; i++) {//最大受理窗口为5个，模拟6个顾客
final int t = i;
p.execute(() -> {
System.out.println(Thread.currentThread().getName() + "服务顾客" + t);
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
//**列满了且正在运行的线程数量还小于maximumPoolSize**，那么还是要创建非核心线程**立刻运行这个任务**;
//顾客6，上来就运行了。 3 4 5 顾客，还在排队。
//如果循环8次，新开的 3 4 5 窗口：运行的：依然是：6 7 8顾客。
/*
pool-1-thread-1服务顾客1
pool-1-thread-2服务顾客2
pool-1-thread-3服务顾客6*/
p.shutdown();
合理配置线程池
CPU密集型：逻辑多，while 循环。
CPU密集的意思是该任务**需要大量的运算，而没有阻塞，CPU一直全速运行。**CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，
而在单核CPU上(悲剧吧?)，无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些。
CPU密集型任务配置尽可能少的线程数量:
一般公式:CPU核数+1个线程的线程池
- 每核一个去干，不要频繁的切换。
IO密集型：经常操作IO，数据库 redis
-
由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如CPU核数*2
-
IO密集型，即该任务需要大量的IO，即大量的阻塞。
在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。
所以在I0O密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
IO密集型时，大部分线程都阻塞，故需要多配置线程数:
参考公式:CPU核数/1-阻塞系数
阻塞系数在0.8~0.9之间
比如8核CPU:8/1-0.9= 80个线程数
-
8 / 0.1 = 80
-
如果是： 8/0.2 = 40
- 40 - 80 之间，50比较合适。
-
先看是 几核的
System.out.println(Runtime.getRuntime().availableProcessors());
private static final Integer CORE_POOL_SIZE = 50; //核心为50个
private static final Integer MAXIMUM_POOL_SIZE = 1024;//最大为1024
private static final Long KEEP_ALIVE_TIME = 5L;//5秒存活
private static final BlockingQueue<Runnable> WORK_QUEUE = new LinkedBlockingQueue(100);//阻塞队列有100个
private static final TimeUnit UNIT = TimeUnit.SECONDS;
private static final RejectedExecutionHandler HANDLER = new AbortPolicy(); //报错的拒绝策略
死锁
10.死锁编码及定位分析
死锁是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力干涉那它们都将无法推进下去，如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。
- 两个 人拿着手枪，你先放下。
- 妈妈说：先做作业，在玩手机。小明：先玩手机，在做作业。
线程A
- 持有 锁A，试图获取 锁B
线程B
- 持有 锁B，试图获取 锁A
原因和必要添加
死锁主要原因
-
系统资源不足
-
进程运行推进的顺序不合适
-
资源分配不当
-
互斥
-
不可剥夺
-
循环等待
-
请求与保持
死锁极简代码
public class DieLock extends Thread {
private String a;
private String b;
DieLock(String a, String b) {
this.a = a;
this.b = b;
}
@Override
public void run() {
synchronized (a) {
String name = Thread.currentThread().getName();
System.out.println(name + "自己持有：" + a + " 尝试获得：" + b);
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (b) {
System.out.println("获得到另一把锁了");
}
}
}
public static void main(String[] args) {
new DieLock("1", "2").start();
new DieLock("2", "1").start();
}
}
命令查看死锁
java bin目录的指令：
- jps.exe
- jstack.exe 就是：e.printStackTrace();
- java的异常堆栈 信息。
- jstat.exe
linux
- ps -eflgrep XX
- ls -l
window下的java运行程序也有类似ps的查看进程的命令，
但是目前我们需要查看的只是java
- jps = java ps
- jps -l
jps命令定位进程号
jstack找到死锁查看
jps -l #在class文件下执行。找到进程编号。
10792 com.example.demo.lock.DieLock
jstack 10792
"Thread-1":
at com.example.demo.lock.DieLock.run(DieLock.java:27)
- waiting to lock <0x00000006c0eef6f8> (a java.lang.String)
- locked <0x00000006c0eef728> (a java.lang.String)
"Thread-0":
at com.example.demo.lock.DieLock.run(DieLock.java:27)
- waiting to lock <0x00000006c0eef728> (a java.lang.String)
- locked <0x00000006c0eef6f8> (a java.lang.String)
Found 1 deadlock.
其他Linux命令
vmstat
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
1 0 0 264712 2104 5439900 0 0 3 71 25 14 1 2 97 0 0
iostat
vmstate
df (disk free)
df -h
2201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
