场景1:当某个接口响应速度很慢的时候,可以使用多线程提升响应速度。前提是这个接口获取信息的逻辑互相独立,比如首页接口,需要获取列表A,列表B,列表C等,而列表ABC三者之间互相独立(也就是不需要获取到A,就能获取到B),互相之间没有关系。这种情况就可以使用多线程去优化,总耗时为获取3个列表当中耗时最长的那个。
实现方式1,使用Callable+线程池
public class Test {
ExecutorService executorService = Executors.newFixedThreadPool(3);
public List<Object> get(List<String> list, final int threadNum) throws Exception {
// 保存各个线程执行后的结果集
List<Future<List<String>>> futures = new ArrayList<>(3);
Callable<List<String>> task1 = new Callable<List<String>>() {
@Override
public List<String> call() throws Exception {
//获取列表A
List<String> list1 = new ArrayList<>();
return list1;
}
};
Callable<List<String>> task2 = new Callable<List<String>>() {
@Override
public List<String> call() throws Exception {
//获取列表B
List<String> list2 = new ArrayList<>();
return list2;
}
};
Callable<List<String>> task3 = new Callable<List<String>>() {
@Override
public List<String> call() throws Exception {
//获取列表C
List<String> list2 = new ArrayList<>();
return list2;
}
};
//添加线程到队列
futures.add(executorService.submit(task1));
futures.add(executorService.submit(task2));
futures.add(executorService.submit(task3));
//主线程会阻塞在这里,直到3个子线程执行完成
//结果集汇总
List<Object> res = new ArrayList<>();
for (int i = 0; i < futures.size(); i++) {
res.add(futures.get(i).get());
}
executorService.shutdown();
return res;
}
}
实现方式2:使用CompletableFuture实现
(参考https://juejin.cn/post/7140244126679138312#heading-15)
public class CompletableFutureDemo {
public static void main(String[] args) throws Exception, InterruptedException {
new CompletableFutureDemo().getRes();
}
public List<Object> getRes() throws ExecutionException, Exception {
List<Future<List<String>>> futures = new ArrayList<>(3);
CompletableFuture<List<String>> task1 = CompletableFuture.supplyAsync(() -> {
//获取列表A
List<String> list1 = new ArrayList<>();
list1.add("1");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return list1;
}).exceptionally(throwable -> {
return new ArrayList<>();
});
CompletableFuture<List<String>> task2 = CompletableFuture.supplyAsync(() -> {
//获取列表B
List<String> list1 = new ArrayList<>();
list1.add("2");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return list1;
}).exceptionally(throwable -> {
return new ArrayList<>();
});
CompletableFuture<List<String>> task3 = CompletableFuture.supplyAsync(() -> {
//获取列表C
List<String> list1 = new ArrayList<>();
list1.add("3");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return list1;
}).exceptionally(throwable -> {
return new ArrayList<>();
});
futures.add(task1);
futures.add(task2);
futures.add(task3);
List<Object> res = new ArrayList<>();
for (int i = 0; i < futures.size(); i++) {
res.add(futures.get(i).get());
}
return res;
}
}
这里为什么没有使用线程池,其实CompletableFuture类就是使用线程池实现的,使用的是ForkJoinPool实现,这个是基于工作窃取实现的线程池,具体可以自行了解一下ForkJoinPool和ThreadPoolExecutor的区别。
场景2:多线程分批次处理集合数据,不处理重复的数据。比如有一张学生表,数据量很大,你需要根据表当中的姓名和身份证号这两个字段去调用外部接口(外部接口一次只能校验一条数据),校验之后还需要更新这张表。这个时候可以使用多线程分批次处理,大大提高效率。
示例demo:
public class TestApp {
//配置需要同时开启多少个线程进行处理
private final int threadNum = 10;
/**
* @param list 要处理的集合数据,如果查询较慢,可以多线程分批次查询然后汇总在一块
*/
public void handleData(List<User> list) {
int size = list.size();
if (size == 0 || list == null) {
return;
}
ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
List<Future<List<User>>> futures = new ArrayList<Future<List<User>>>(size);
for (int i = 0; i < threadNum; i++) {
//将数据分成threadNum份,线程同时执行
int from = size / threadNum * i;
int to = size / threadNum * (i + 1);
if (i == threadNum - 1) {
to = size;
}
List<User> subList = list.subList(from, to);
Callable<List<User>> task = new Callable<List<User>>() {
@Override
public List<User> call() {
List<User> list1 = new ArrayList<>();
//对每个线程(线程中的每份数据)的逻辑操作
for (User user : subList) {
//调用外部接口
Boolean res = checkNameAndIdCard(user.getName, user.getIdCard);
user.setRes(res);
list1.add(user);
}
return list1;
}
};
//添加线程到队列
futures.add(executorService.submit(task));
}
//多线程处理后的集合汇总到all
List<User> all = new ArrayList<>();
for (int i = 0; i < futures.size(); i++) {
try {
List<User> list1 = futures.get(i).get();
all.addAll(list1);
} catch (Exception e) {
e.printStackTrace();
}
}
//批量更新数据库
executorService.shutdown();
}
/**
* 模拟外部接口
*/
public Boolean checkNameAndIdCard(String name, String idCard) {
return true;
}
}
@Data
class User {
private Integer id;
private String name;
private String idCard;
private String res;
}
整体流程:
先把要处理的集合从数据库全部捞出来
根据要开的线程数量对集合进行均分
开多线程对每个集合进行处理,处理后返回结果
Future.get()会造成主线程阻塞,也就是当所有future都得到结果后主线程才能继续执行下去
场景3:做异步。比如页面上需要导出excel文件,由于业务要求,需要导出全部数据,导出全部数据大概需要10分钟左右,那如果使用同步的方式,用户需要在这个导出页面等待10分钟,不能做其它操作,这样肯定是不行的。那么可以采用异步,用户点击导出,导出接口主线程往数据库当中插入一条导出记录,开个子线程获取数据,写入Excel文件,完成之后更新导出记录,当中,然后主线程直接给用户返回。这样用户点击导出会生成一个导出记录信息,不用在这里等待,等导出完成,之后可以在导出记录当中进行下载。代码就不贴了。
场景4:监听线程,如果某个线程执行时间过长(可能死循环了),超过了自定义的时间,就把该线程干掉,释放cpu资源
情况1:开一个线程去执行这个任务
示例demo:
public class MainSingle {
public static final ExecutorService pool = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws Exception {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "进来了" + this.hashCode());
try {
Thread.sleep(7000);
} catch (InterruptedException e) {}
}
};
FutureTask futureTask = new FutureTask<>(runnable,null);
pool.submit(futureTask);
long start = System.currentTimeMillis();
// 判断是否完成,如果没完成就是一直循环判断
while (!futureTask.isDone()) {
long now = System.currentTimeMillis();
if ((now - start) >= 6000) {//超时时间3000毫秒
futureTask.cancel(true);
System.out.println("线程超时了,终止");
}
}
pool.shutdown();
}
}
情况2:开多个线程,哪个线程死循环,就关闭哪一个线程,不影响其它线程
public class MainMore implements Runnable {
//线程池
public static final ExecutorService pool = Executors.newFixedThreadPool(12);
@Override
public void run() {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "进来了" + this.hashCode());
try {
Thread.sleep(7000);
} catch (InterruptedException e) {
}
}
};
FutureTask task = new FutureTask(runnable, null);
new Thread(task).start();
long start = System.currentTimeMillis();
while (!task.isDone()) {// 判断是否完成
long now = System.currentTimeMillis();
if ((now - start) >= 3000) {//超时时间3000毫秒
task.cancel(true);
System.out.println(Thread.currentThread().getName() + "线程超时了,终止");
}
}
}
public static void main(String[] args) throws Exception {
for (int i = 0; i < 3; i++) {
pool.submit(new MainMore());
}
pool.shutdown();
}
}
以上是我在工作当中真实遇到的一个多线程使用场景,在这里做一个小总结。