示例1:一个简单的示例
我们使用CountDownLatch来完成上面示例中使用join实现的功能,代码如下:
package com.itsoku.chat13;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
- 微信公众号:javacode2018,获取年薪50万课程
*/
public class Demo2 {
public static class T extends Thread {
//休眠时间(秒)
int sleepSeconds;
CountDownLatch countDownLatch;
public T(String name, int sleepSeconds, CountDownLatch countDownLatch) {
super(name);
this.sleepSeconds = sleepSeconds;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
Thread ct = Thread.currentThread();
long startTime = System.currentTimeMillis();
System.out.println(startTime + “,” + ct.getName() + “,开始处理!”);
try {
//模拟耗时操作,休眠sleepSeconds秒
TimeUnit.SECONDS.sleep(this.sleepSeconds);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
long endTime = System.currentTimeMillis();
System.out.println(endTime + “,” + ct.getName() + “,处理完毕,耗时:” + (endTime - startTime));
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 start!”);
CountDownLatch countDownLatch = new CountDownLatch(2);
long starTime = System.currentTimeMillis();
T t1 = new T(“解析sheet1线程”, 2, countDownLatch);
t1.start();
T t2 = new T(“解析sheet2线程”, 5, countDownLatch);
t2.start();
countDownLatch.await();
System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 end!”);
long endTime = System.currentTimeMillis();
System.out.println(“总耗时:” + (endTime - starTime));
}
}
输出:
1563767580511,main线程 start!
1563767580513,解析sheet1线程,开始处理!
1563767580513,解析sheet2线程,开始处理!
1563767582515,解析sheet1线程,处理完毕,耗时:2002
1563767585515,解析sheet2线程,处理完毕,耗时:5002
1563767585515,main线程 end!
总耗时:5003
从结果中看出,效果和join实现的效果一样,代码中创建了计数器为2的 CountDownLatch
,主线程中调用 countDownLatch.await();
会让主线程等待,t1、t2线程中模拟执行耗时操作,最终在finally中调用了 countDownLatch.countDown();
,此方法每调用一次,CountDownLatch内部计数器会减1,当计数器变为0的时候,主线程中的await()会返回,然后继续执行。注意:上面的 countDown()
这个是必须要执行的方法,所以放在finally中执行。
示例2:等待指定的时间
还是上面的示例,2个线程解析2个sheet,主线程等待2个sheet解析完成。主线程说,我等待2秒,你们还是无法处理完成,就不等待了,直接返回。如下代码:
package com.itsoku.chat13;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
- 微信公众号:javacode2018,获取年薪50万课程
*/
public class Demo3 {
public static class T extends Thread {
//休眠时间(秒)
int sleepSeconds;
CountDownLatch countDownLatch;
public T(String name, int sleepSeconds, CountDownLatch countDownLatch) {
super(name);
this.sleepSeconds = sleepSeconds;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
Thread ct = Thread.currentThread();
long startTime = System.currentTimeMillis();
System.out.println(startTime + “,” + ct.getName() + “,开始处理!”);
try {
//模拟耗时操作,休眠sleepSeconds秒
TimeUnit.SECONDS.sleep(this.sleepSeconds);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
}
long endTime = System.currentTimeMillis();
System.out.println(endTime + “,” + ct.getName() + “,处理完毕,耗时:” + (endTime - startTime));
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 start!”);
CountDownLatch countDownLatch = new CountDownLatch(2);
long starTime = System.currentTimeMillis();
T t1 = new T(“解析sheet1线程”, 2, countDownLatch);
t1.start();
T t2 = new T(“解析sheet2线程”, 5, countDownLatch);
t2.start();
boolean result = countDownLatch.await(2, TimeUnit.SECONDS);
System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 end!”);
long endTime = System.currentTimeMillis();
System.out.println(“主线程耗时:” + (endTime - starTime) + “,result:” + result);
}
}
输出:
1563767637316,main线程 start!
1563767637320,解析sheet1线程,开始处理!
1563767637320,解析sheet2线程,开始处理!
1563767639321,解析sheet1线程,处理完毕,耗时:2001
1563767639322,main线程 end!
主线程耗时:2004,result:false
1563767642322,解析sheet2线程,处理完毕,耗时:5002
从输出结果中可以看出,线程2耗时了5秒,主线程耗时了2秒,主线程中调用 countDownLatch.await(2,TimeUnit.SECONDS);
,表示最多等2秒,不管计数器是否为0,await方法都会返回,若等待时间内,计数器变为0了,立即返回true,否则超时后返回false。
示例3:2个CountDown结合使用的示例
有3个人参见跑步比赛,需要先等指令员发指令枪后才能开跑,所有人都跑完之后,指令员喊一声,大家跑完了。
示例代码:
package com.itsoku.chat13;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
- 微信公众号:javacode2018,获取年薪50万课程
*/
public class Demo4 {
public static class T extends Thread {
//跑步耗时(秒)
int runCostSeconds;
CountDownLatch commanderCd;
CountDownLatch countDown;
public T(String name, int runCostSeconds, CountDownLatch commanderCd, CountDownLatch countDown) {
super(name);
this.runCostSeconds = runCostSeconds;
this.commanderCd = commanderCd;
this.countDown = countDown;
}
@Override
public void run() {
//等待指令员枪响
try {
commanderCd.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread ct = Thread.currentThread();
long startTime = System.currentTimeMillis();
System.out.println(startTime + “,” + ct.getName() + “,开始跑!”);
try {
//模拟耗时操作,休眠runCostSeconds秒
TimeUnit.SECONDS.sleep(this.runCostSeconds);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDown.countDown();
}
long endTime = System.currentTimeMillis();
System.out.println(endTime + “,” + ct.getName() + “,跑步结束,耗时:” + (endTime - startTime));
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 start!”);
CountDownLatch commanderCd = new CountDownLatch(1);
CountDownLatch countDownLatch = new CountDownLatch(3);
long starTime = System.currentTimeMillis();
T t1 = new T(“小张”, 2, commanderCd, countDownLatch);
t1.start();
T t2 = new T(“小李”, 5, commanderCd, countDownLatch);
t2.start();
T t3 = new T(“路人甲”, 10, commanderCd, countDownLatch);
t3.start();
//主线程休眠5秒,模拟指令员准备发枪耗时操作
TimeUnit.SECONDS.sleep(5);
System.out.println(System.currentTimeMillis() + “,枪响了,大家开始跑”);
commanderCd.countDown();
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “所有人跑完了,主线程耗时:” + (endTime - starTime));
}
}
输出:
1563767691087,main线程 start!
1563767696092,枪响了,大家开始跑
1563767696092,小张,开始跑!
1563767696092,小李,开始跑!
1563767696092,路人甲,开始跑!
1563767698093,小张,跑步结束,耗时:2001
1563767701093,小李,跑步结束,耗时:5001
1563767706093,路人甲,跑步结束,耗时:10001
1563767706093,main所有人跑完了,主线程耗时:15004
代码中,t1、t2、t3启动之后,都阻塞在 commanderCd.await();
,主线程模拟发枪准备操作耗时5秒,然后调用 commanderCd.countDown();
模拟发枪操作,此方法被调用以后,阻塞在 commanderCd.await();
的3个线程会向下执行。主线程调用 countDownLatch.await();
之后进行等待,每个人跑完之后,调用 countDown.countDown();
通知一下 countDownLatch
让计数器减1,最后3个人都跑完了,主线程从 countDownLatch.await();
返回继续向下执行。
手写一个并行处理任务的工具类
package com.itsoku.chat13;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
- 微信公众号:javacode2018,获取年薪50万课程
*/
public class TaskDisposeUtils {
//并行线程数
public static final int POOL_SIZE;
static {
POOL_SIZE = Integer.max(Runtime.getRuntime().availableProcessors(), 5);
}
/**
-
并行处理,并等待结束
-
@param taskList 任务列表
-
@param consumer 消费者
-
@param <T>
-
@throws InterruptedException
*/
public static <T> void dispose(List<T> taskList, Consumer<T> consumer) throws InterruptedException {
dispose(true, POOL_SIZE, taskList, consumer);
}
/**
-
并行处理,并等待结束
-
@param moreThread 是否多线程执行
-
@param poolSize 线程池大小
-
@param taskList 任务列表
-
@param consumer 消费者
-
@param <T>
-
@throws InterruptedException
*/
public static <T> void dispose(boolean moreThread, int poolSize, List<T> taskList, Consumer<T> consumer) throws InterruptedException {
if (CollectionUtils.isEmpty(taskList)) {
return;
}
if (moreThread && poolSize > 1) {
poolSize = Math.min(poolSize, taskList.size());
ExecutorService executorService = null;
try {
executorService = Executors.newFixedThreadPool(poolSize);
CountDownLatch countDownLatch = new CountDownLatch(taskList.size());
for (T item : taskList) {
executorService.execute(() -> {
try {
consumer.accept(item);
} finally {
countDownLatch.countDown();
}
});
}
countDownLatch.await();
} finally {
if (executorService != null) {
executorService.shutdown();
}
}
} else {
for (T item : taskList) {
consumer.accept(item);
}
}
}
public static void main(String[] args) throws InterruptedException {
//生成1-10的10个数字,放在list中,相当于10个任务
List<Integer> list = Stream.iterate(1, a -> a + 1).limit(10).collect(Collectors.toList());
//启动多线程处理list中的数据,每个任务休眠时间为list中的数值
TaskDisposeUtils.dispose(list, item -> {
try {
long startTime = System.currentTimeMillis();
TimeUnit.SECONDS.sleep(item);
long endTime = System.currentTimeMillis();
System.out.println(System.currentTimeMillis() + “,任务” + item + “执行完毕,耗时:” + (endTime - startTime));
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//上面所有任务处理完毕完毕之后,程序才能继续
System.out.println(list + “中的任务都处理完毕!”);
}
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/5babab09c333ac5aa209c955e865b454.jpeg)
总结
面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式,就会容易很多。
此外,都说“面试造火箭,工作拧螺丝”,那对于准备面试的朋友,你只需懂一个字:刷!
给我刷刷刷刷,使劲儿刷刷刷刷刷!今天既是来谈面试的,那就必须得来整点面试真题,这不花了我整28天,做了份“Java一线大厂高岗面试题解析合集:JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
且除了单纯的刷题,也得需准备一本【JAVA进阶核心知识手册】:JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算,用来查漏补缺最好不过。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式,就会容易很多。
此外,都说“面试造火箭,工作拧螺丝”,那对于准备面试的朋友,你只需懂一个字:刷!
给我刷刷刷刷,使劲儿刷刷刷刷刷!今天既是来谈面试的,那就必须得来整点面试真题,这不花了我整28天,做了份“Java一线大厂高岗面试题解析合集:JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
[外链图片转存中…(img-PMZ5UOd7-1713498988904)]
且除了单纯的刷题,也得需准备一本【JAVA进阶核心知识手册】:JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算,用来查漏补缺最好不过。
[外链图片转存中…(img-cDyxjF7g-1713498988905)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!