Callable,阻塞队列,线程池问题
月上贺兰 人气:1一.说说Java创建多线程的方法
1. 通过继承Thread类实现run方法
2. 通过实现Runnable接口
3. 通过实现Callable接口
4. 通过线程池获取
二. 可以写一个Callable的案例吗?如何调用Callable接口
/*是一个带返回值的多线程类,如果需要有线程返回的结果,就需要使用此类*/
class MyThread implements Callable<Integer> {
@Override
public Integer call() {
return 1000;
}
}
public static void main(String[] args) throws Exception{
/*Thread 构造方法传入 Runnable , FutureTask 构造方法传入 Callable ,
FutureTask 继承于 RunnableFuture 继承于 Runnable
所以 Thread通过传入FutureTask即Runnable的实现类来启动Callable线程,
透传思想,传接口,不传具体的实现类,可以保证灵活性,(适配器模式)
*/
FutureTask<Integer> ft = new FutureTask(new MyThread());// 一个是main线程,一个是t1线程
new Thread(ft,"t1").start();
int res1 = 1000;
// 获取t1线程中的返回值,建议放在最后
// 如果没有计算完成就取值,会导致整个程序阻塞,直到t1执行完成
int res2 = ft.get();
//自旋锁,如果t1线程没有计算完成,就等待
while (!ft.isDone()){
}
System.out.println(Thread.currentThread().getName() + "\t"+(res1+res2));
}
三. 请你谈谈对阻塞队列的理解,为什么要是用阻塞队列,它有哪些具体的实现,各有什么特点?
在多线程的环境下,所谓阻塞,在某些情况下会挂起线程,一旦条件满足,被挂起的线程又被唤醒.我们不需要关心
什么时候需要阻塞线程,什么时候需要唤醒线程,一切都有BlockingQueue自动调度实现
它有7个实现类
* 1.ArrayBlockingQueue 由数组构成的有序阻塞队列
* 2.LinkedBlockingQueue 由链表构成的有序阻塞队列
* 3.PriorityBlockingQueue 支持优先级排序的无界阻塞队列
* 4.DelayQueue 使用优先级队列的延迟无阻塞队列
* 5.SynchronousQueue 不存储元素的阻塞队列,也即单元素队列
* 6.LinkedTransferQueue 由链表组成的无界阻塞队列
* 7.LinkedBlockingQueue 由链表构成的双向阻塞队列
1,2,5用的最多
BlockingQueue的使用方法
1.会抛出异常
public static void show01(int n){
/*队列中的数据错误,会抛出异常*/
/*add 队列满了,再继续插入会抛出java.lang.IllegalStateException: Queue full异常*/
/*remove 从队列中移除一个元素,并返回该元素,如果队列为空,就抛出java.util.NoSuchElementException异常*/
/*element 返回队列的首个元素,如果队列为空,抛出java.util.NoSuchElementException异常*/
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
// System.out.println(blockingQueue.add("x"));
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
//System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.element());//
}
2.不会抛出异常
public static void show02(int n){
/*队列数据错误,不会抛出异常*/
/*offer 添加元素,如果队列满了,再继续插入元素,会返回false*/
/*poll 获取元素,如果队列为空,再继续获取元素,会返回null*/
/*peek 获取队列的首元素,如果队列为空,返回null*/
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
// System.out.println(blockingQueue.offer("x"));
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
// System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.peek());
}
3.队列阻塞
public static void show03(int n){
/*队列数据异常,不会抛出异常,没有返回值*/
/*put 如果队列已满,在插入元素,队列会阻塞*/
/*take 如果队列为空,在获取元素,队列会阻塞*/
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
try {
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
// blockingQueue.put("x");
System.out.println("-------------------");
blockingQueue.take();
blockingQueue.take();
blockingQueue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
4.队列超时 (实际用的较多)
public static void show04(int n){
/*队列数据异常,不会抛出异常,返回true/false值*/
/*offer 传入值,等待时间,等待单位,往队列中存放元素,当队列中的元素已满,继续等待,如果超过给定时间,那么就会丢弃元素*/
/*poll 等待时间,等待单位,从队列中获取元素,当队列中的元素为空,继续等待,如果超过给定时间,那么就不会获取*/
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
try {
System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("b", 2L, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("c", 2L, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("x", 2L, TimeUnit.SECONDS));
blockingQueue.poll(2L,TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
show01(3); // 异常
show02(3); // 没有异常
show03(3); // 阻塞
show04(3); // 超时等待
}
四.请你谈谈对线程池的理解,为什么要使用线程池,如何使用线程池?
介绍:线程池的主要是控制运行的线程的数量,如果处理过程中将任务加入队列,然后在线程创建的时候启动这些任务.如果线程数量超过了最大数量的线程将排队等候,等待其他的线程执行完毕,再从队列中取出任务来执行.
优点:
1.降低资源消耗,通过复用已创建的线程降低线程创建和销毁造成的消耗
2.提高响应速度,当任务达到时,任务可以不需要等待线程创建就可以立刻执行
3.提高线程的可管理性,线程属于稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性
使用线程池可以进行统一的分配,调优和监控
一句话总结:线程复用,控制最大并发数,管理线程
public static void show01(ExecutorService es){
// 创建1个线程池,里面有5个固定的线程
/*1. 创建一个定长的线程池,可控制线程的最大并发数,超出的线程会在队列中等待
* 2. newFixedThreadPool创建的线程池corePoolSize和maxPoolSize的值事相等的,使用的是LinkedBlockingQueue
* */
es = Executors.newFixedThreadPool(5);
try{
// 有10个任务等待被执行
for (int i = 1; i <= 10; i++) {
es.execute(()->{
System.out.println(Thread.currentThread().getName() +"\t 执行任务");
});
}
}catch (Exception e){
e.getStackTrace();
}finally {
es.shutdown();//关闭线程池
}
}
public static void show02(ExecutorService es){
// 创建1个线程池,里面有1个固定的线程
/*
* 1.创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有的任务按照指定的顺序执行
* 2.newSingleThreadExecutor将corePoolSize和maxPoolSize的值都设置为1,使用的是LinkedBlockingQueue
* */
es = Executors.newSingleThreadExecutor();
try{
for (int i = 1; i <= 10; i++) {
es.execute(()->{
System.out.println(Thread.currentThread().getName() +"\t 执行任务");
});
}
}catch (Exception e){
e.getStackTrace();
}finally {
es.shutdown();//关闭线程池
}
}
public static void show03(ExecutorService es){
// 创建1个线程池,里面无固定个线程
/*
* 1.创建一个可缓存的线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则创建新线程
* 2.newCachedThreadPool将corePoolSize的值设置为0,maxPoolSize的值设置为Integer.MAX_VALUE,使用
* 的是synchronousQueue,也就是说来了任务就创建线程运行,当线程空闲超过60秒,就销毁线程
*
* */
es = Executors.newCachedThreadPool();
try{
for (int i = 1; i <= 10; i++) {
es.execute(()->{
System.out.println(Thread.currentThread().getName() +"\t 执行任务");
});
}
}catch (Exception e){
e.getStackTrace();
}finally {
es.shutdown();//关闭线程池
}
}
public static void main(String[] args) {
ExecutorService es = null;
show01(es);
show02(es);
show03(es);
}
五. 请你谈一谈线程池的七大/五大参数分别代表什么意思
int corePoolSize 线程池中常驻核心线程数
* 1.在创建了线程池后,当有请求任务来了之后,就会安排线程池中的线程去执行请求的任务,类似于银行当值的窗口
* 2.当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中
int maximumPoolSize 线程池同时能够容纳同时执行的最大线程数,此值必须大于等于1
long keepAliveTime 多余的空闲线程的存活时间
* 当前线程池数量超过corePoolSize时,空闲时间达到keepAliveTime值时,多余线程会被销毁直到只剩下corePoolSize个线程为止
* 默认情况下,只有当线程池中的线程数大于corePoolSize时候keepAliveTime才会起作用,直到线程池中的线程数不大于corePoolSize
*
TimeUnit unit keepAliveTime的单位
BlockingQueue<Runnable> workQueue 任务队列,被提交但尚未被执行的任务
ThreadFactory threadFactory 表示生成线程池中工作线程的线程工厂,用于创建线程,一般用默认的值即可
RejectedExecutionHandler handler 拒绝策略,表示当队列满了并且工作线程大于等于线程池的最大线程数(maximumPoolSize)如何来拒绝请求执行的Runnable策略
六.请你谈一谈线程池的底层工作原理
1.在创建了线程池后,等待提交过来的任务请求
2.当调用execute方法添加一个任务请求时,线程池会做出如下判断:
2.1 如果正在运行的线程数量小于corePoolSize,那么会马上创建这个线程并执行这个任务
2.2 如果此时正在运行的线程数量大于或等于corePoolSize,那么会将这个这个任务放进阻塞队列中等待
2.3 如果此时阻塞队列满了且正在运行的线程数量小于maximumPoolSize,那么会创建非核心线程来立即执行这些任务
2.4 如果此时阻塞队列满了且正在运行的线程数大于或等于maximumPoolSize.那么线程池会启用饱和拒绝策略来拒绝新的请求
3.当一个线程完成任务时,会从阻塞队列中取出下一个任务来执行
4.此时当一个线程空闲并超过一定的时间keepAliveTime,此时线程池会判断,如果当前运行的线程数量大于corePoolSize,那么这些线程将会被终止.
所以线程池的所有任务完成后,最终会收缩到corePoolSize的大小.
举列子:银行办理业务,周六招商银行,一共有5个柜面,只开放了2个柜台办理业务,此时2就代表corePoolSize,5个柜台代表了maximumPoolSize,只有2个员工在干活,
其他的3个柜台都是空闲的当有人来进去办业务,如果来的人少于2人可以立即办理业务,无需等待,当来了5个人办理业务,前面的1,2号没有办完,此时3,4,5号就
会进入候客区等待.也就是线程池中的阻塞队列中等待被执行.如果此时来银行办理业务的任实在太多,来了7,8,9,候客区也满了(BlockingQueue满了),此时银行
行长就会开放剩余的柜台来处理业务(非核心线程打开,此时线程数达到最大值),打电话给另外3个柜员来加班,此时柜台全部开放,也满足不了新的客户需求,那么
最后银行行长就会暂时关闭这个网点(拒绝策略拒绝新的请求),先来办理行内的业务.当解决了一个任务时,就会叫下一个号来办理业务(从阻塞队列中获取待
解决的任务).如果过了一个小时(keepAliveTime保留活跃时间),银行的流量下降了,此时,加班的3个人可以先回去(本来也不该他们上班),银行重新回归到初始状
态.(这么说,小伙伴们懂了吗~)
七. 请你谈一谈线程池的拒绝策略
此时线程池中的阻塞队列已经被塞满,再也放不进新的任务,同时线程数也达到了maximumPoolSize,无法为新的请求服务,此时JDK有4种拒绝策略
1.AbortPolicy(默认) 直接抛出RejectedExecutionException异常阻止系统正常运行 2.CallersRunsPolicy "调用者模式"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将某些任务回退到调用者,从而降低新任务的流量 3.DiscardOldestPolicy 抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交当前任务 4.DiscardPolicy 直接丢弃任务,不予处理也不抛出异常.如果允许任务丢失,这是最好的一种方案
那此时可以说下在工作中用了哪一种线程池?(此处有坑)
JDK提供的线程池一律不能说,标准答案: 根据业务的需要,自定义ThreadPoolExectuor来创建线程池.
public static void show04(ExecutorService es){
// 核心线程数为2,最大线程数为5,非核心线程的最大运行时间是1秒
// 阻塞队列中一共有3个等待的任务,使用默认的线程生成策略,同时开启
// 调用者模式的拒绝策略
es = new ThreadPoolExecutor(
2,5,1L, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
try{
for (int i = 1; i <= 10; i++) { // 开启10个请求,最大线程数量是8,
es.execute(()->{
System.out.println(Thread.currentThread().getName()+"\t办理业务");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
es.shutdown();
}
}
运行结果:
AbortPolicy,直接抛出异常
CallersRunsPolicy 不会抛出异常,返回给方法的调用者,也就是main线程
DiscardOldestPolicy 抛弃队列中等待最久的任务
DiscardPolicy 直接抛弃队列中多余的任务,如果业务允许,此拒绝策略效率最高
八. 请你谈一谈,如何在实际的生产业务中确定线程池中参数的配置
此时要根据实际做的系统进行分类
1.CPU密集型
/*指的是该任务需要大量的运算,没有阻塞,CPU一直全速运行,CPU密集任务只有真正的多核心CPU才能得到加速(通过多线程)而在单核CPU上
无论开几个模拟多线程的任务都不可能得到加速,因为CPU的运算能力有限. 1.CPU密集型的任务尽可能少配线程数量 2.公式:线程数 = CPU核心数 + 1个线程的线程池(8核就开启8个线程,12核开启12个线程,尽量减少切换) 3.System.out.println(Runtime.getRuntime().availableProcessors());//查看CPU的核心数*/
2.I/O密集型
/* 1.I/O密集型并不是在一直执行任务,应该配置尽可能多的线程,线程数 = CPU核心数 * 2
2.I/O密集型即该任务需要大量的I/O操作,业务系统中大量的阻塞(从数据库,缓存获取数据,修改数据...)
所以在I/O密集型的场景中,使用多线程可以大大加速程序运行,即使在单核CPU上,这种加速也可以利用了被浪费掉的阻塞时间
因为大部分线程都会阻塞,需要配置大量的线程数
线程数 = CPU核心数 / 1-阻塞系数 阻塞系数在0.8~0.9之间
(例如 8核心CPU 8 / 1 - 0.9 = 80,如果是I/O密集型的操作,需要配置80个线程数)
*/
加载全部内容