一 序
传统的thread里面,在执行完任务之后无法获取执行结果。通过共享变量或者使用线程通信获取结果,比较麻烦。
就是Runnable接口,线程的真正业务在run里面。
jdk1.5 开始提供Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果。
二 future
Callable 和Future位于
java.util.concurrent 包下。
Callable 是个接口,只有一个方法call().通常配合ExecutorService使用。
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。参见api.归纳如下:
1)判断任务是否完成;2)能够中断任务;3)能够获取任务执行结果。
demo:
package com.daojia.future;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
*
* @author daojia
*
*/
public class FutureTest {
public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
// TODO Auto-generated method stub
useFuture();
}
private static void useFuture() throws InterruptedException, ExecutionException, TimeoutException {
ExecutorService exector = Executors.newFixedThreadPool(3);
Future<Integer> futureA = (Future<Integer>) exector.submit(new Task("A1"));
Future<Integer> futureB = (Future<Integer>) exector.submit(new Task("B1"));
System.out.println("a,b请求完成");
int a= futureA.get(1, TimeUnit.SECONDS);
int b = futureB.get(1, TimeUnit.SECONDS);
exector.shutdown();
System.out.println("所有任务执行完毕,res="+(a+b));
}
}
class Task implements Callable<Integer>{
private String name;
public Task(String name){
this.name = name;
}
@Override
public Integer call() throws Exception {
System.out.println(System.currentTimeMillis()+" "+name+"run");
Random random = new Random();
int num = random.nextInt(100);
Thread.sleep(num);
System.out.println(System.currentTimeMillis()+" "+name+"runover,res="+num);
return num;
}
}
模拟一个耗时的task,主线程负责汇总结果。,结果如下
a,b请求完成
1508849841494 A1run
1508849841495 B1run
1508849841503 B1runover,res=8
1508849841582 A1runover,res=87
所有任务执行完毕,res=95
三 JDK8 CompletableFuture
jdk8CompletableFuture还提供了新的功能,可以对多个异步处理程序进行编排
demo:
public class FutureTest {
public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
// TODO Auto-generated method stub
useCompletableFuture();
}
private static void useCompletableFuture() throws InterruptedException, ExecutionException {
System.out.println("CompletableFuture");
CompletableFuture<Void> futureA = CompletableFuture.runAsync(() -> Task("A2"));
CompletableFuture<Void> futureB = CompletableFuture.runAsync(() -> Task("B2"));
futureA.runAfterEither(futureB, () ->Task("C2")).get();
}
private static Object Task(String name) {
System.out.println(name + " starts at " + LocalTime.now());
try {
Random random = new Random();
TimeUnit.SECONDS.sleep(random.nextInt(10));
} catch (InterruptedException e) {
}
System.out.println(name + " ends at " + LocalTime.now());
return null;
}
}
运行:
CompletableFuture
A2 starts at 21:19:43.562
B2 starts at 21:19:43.562
A2 ends at 21:19:45.563
C2 starts at 21:19:45.563
B2 ends at 21:19:46.563
C2 ends at 21:19:54.563
可见,在A或者B先处理完,C就再启动。
补充一份jdk8里面相关的类图
这块需要深入的学习。API很多不同的方法支持灵活的编排。