Java在语言层面提供了多线程的支持,线程池能够避免频繁的线程创建和销毁的开销,因此很多时候在项目当中我们是使用的线程池去完成多线程的任务。
Java提供了Executors 框架提供了一些基础的组件能够轻松的完成多线程异步的操作,Executors提供了一系列的静态工厂方法能够获取不同的ExecutorService实现,ExecutorService扩展了Executors接口,Executors相当简单:
public interface Executor {
void execute(Runnable command);
}
1
2
3
4
把任务本身和任务的执行解耦了,如果说Runnable是可异步执行任务的抽象,那Executor就是如何执行可异步执行任务的抽象,说起来比较绕口。
本文不讲解线程的一些基础知识,因为网上的其他文章已经写的足够详细和泛滥。我写写多个异步任务的并发执行与结果的获取问题。假设这样一个场景:我们要组装一个对象,这个对象由大量小的内容组成,这些内容是无关联无依赖关系的,如果我们串行的去执行,如果每个任务耗时10秒钟,一共有10个任务,那我们就需要100秒才能获取到结果。显然我们可以采用线程池,每个任务起一个线程,忽略线程启动时间,我们只需要10秒钟就能获取到结果。这里还有两种选择,这10秒钟我们可以去做其他事,也可以等待结果。
我们来完成这样的操作:
// 这是任务的抽象
class GetContentTask implements Callable {
private String name;
private Integer sleepTimes;
public GetContentTask(String name, Integer sleepTimes) {
this.name = name;
this.sleepTimes = sleepTimes;
}
public String call() throws Exception {
// 假设这是一个比较耗时的操作
Thread.sleep(sleepTimes * 1000);
return "this is content : hello " + this.name;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
采用completionService :
// 方法一
ExecutorService executorService = Executors.newCachedThreadPool();
CompletionService completionService = new ExecutorCompletionService(executorService);
ExecuteServiceDemo executeServiceDemo = new ExecuteServiceDemo();
// 十个
long startTime = System.currentTimeMillis();
int count = 0;
for (int i = 0;i < 10;i ++) {
count ++;
GetContentTask getContentTask = new ExecuteServiceDemo.GetContentTask("micro" + i, 10);
completionService.submit(getContentTask);
}
System.out.println("提交完任务,主线程空闲了, 可以去做一些事情。");
// 假装做了8秒种其他事情
try {
Thread.sleep(8000);
System.out.println("主线程做完了,等待结果");
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
// 做完事情要结果
for (int i = 0;i < count;i ++) {
Future result = completionService.take();
System.out.println(result.get());
}
long endTime = System.currentTimeMillis();
System.out.println("耗时 : " + (endTime - startTime) / 1000);
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
执行结果为:
提交完任务,主线程空闲了, 可以去做一些事情。
主线程做完了,等待结果
this is content : hello micro9
this is content : hello micro7
this is content : hello micro2
this is content : hello micro5
this is content : hello micro4
this is content : hello micro8
this is content : hello micro1
this is content : hello micro3
this is content : hello micro0
this is content : hello micro6
耗时 : 10
1
2
3
4
5
6
7
8
9
10
11
12
13
如果多个不想一个一个提交,可以采用 invokeAll一并提交,但是会同步等待这些任务
// 方法二
ExecutorService executeService = Executors.newCachedThreadPool();
List taskList = new ArrayList();
long startTime = System.currentTimeMillis();
for (int i = 0;i < 10;i ++) {
taskList.add(new GetContentTask("micro" + i, 10));
}
try {
System.out.println("主线程发起异步任务请求");
List> resultList = executeService.invokeAll(taskList);
// 这里会阻塞等待resultList获取到所有异步执行的结果才会执行
for (Future future : resultList) {
System.out.println(future.get());
}
// 主线程假装很忙执行8秒钟
Thread.sleep(8);
long endTime = System.currentTimeMillis();
System.out.println("耗时 : " + (endTime - startTime) / 1000);
} catch (Exception e) {
e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
主线程发起异步任务请求
this is content : hello micro0
this is content : hello micro1
this is content : hello micro2
this is content : hello micro3
this is content : hello micro4
this is content : hello micro5
this is content : hello micro6
this is content : hello micro7
this is content : hello micro8
this is content : hello micro9
耗时 : 10
1
2
3
4
5
6
7
8
9
10
11
12
如果一系列请求,我们并不需要等待每个请求,我们可以invokeAny,只要某一个请求返回即可。
ExecutorService executorService = Executors.newCachedThreadPool();
ArrayList taskList = new ArrayList();
taskList.add(new GetContentTask("micro1",3));
taskList.add(new GetContentTask("micro2", 6));
try {
List> resultList = executorService.invokeAll(taskList);// 等待6秒
//String result2 = executorService.invokeAny(taskList); // 等待3秒
// invokeAll 提交一堆任务并行处理并拿到结果
// invokeAny就是提交一堆并行任务拿到一个结果即可
for (Future result : resultList) {
System.out.println(result.get());
}
//System.out.println(result2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("主线程等待");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
如果我虽然发送了一堆异步的任务,但是我只等待一定的时间,在规定的时间没有返回我就不要了,例如很多时候的网络请求其他服务器如果要数据,由于网络原因不能一直等待,在规定时间内去拿,拿不到就我使用一个默认值。这样的场景,我们可以使用下面的写法:
try {
ExecutorService executorService = Executors.newCachedThreadPool();
List> taskList = new ArrayList>();
taskList.add(new GetContentTask("micro1", 4));
taskList.add(new GetContentTask("micro2", 6));
// 等待五秒
List> resultList = executorService.invokeAll(taskList, 5, TimeUnit.SECONDS);
for (Future future : resultList) {
System.out.println(future.get());
}
} catch (Exception e) {
e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
this is content : hello micro1
java.util.concurrent.CancellationException
at java.util.concurrent.FutureTask.report(FutureTask.java:121)
at java.util.concurrent.FutureTask.get(FutureTask.java:192)
at com.micro.demo.spring.ExecuteServiceDemo.main(ExecuteServiceDemo.java:105)
1
2
3
4
5
因为只等待5秒,6秒的那个任务自然获取不到,抛出异常,如果将等待时间设置成8秒,就都能获取到。