java 并发callable/Future/FutureTas
前提:在进行多线程编程时java提供了2种方式,类继承Thread,或者实现Runnable接口
这两种使用方式都有一个特点,就是线程异步执行,无法获取线程执行结果.
在java1.5之前如果我们想要拿到执行结果,一般就是
1)定义共享变量
2)线程之间的通讯
在java1.5之后java提供了Callable 和Future为程序猴们提供了上面那种场景的解决方案.
目录:
1 Callable
2 Future
3 FutureTask
1 Callbale说明
@FunctionalInterfacepublic
interface Callable<V> {
V call() throws Exception;
}
该接口声明了泛型,call()函数返回的类型就是调用者传递进来的V类型.
注意:
1 Callable规定的方法是call()，而Runnable规定的方法是run().
2 Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
3 call()方法可抛出异常，而run()方法是不能抛出异常的。
也就是说Callable定义了一个类似于Runnable的接口,声明的call()方法是有返回值的.
2 Future说明
类图
Future接口定义了5个接口方法(因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。):
get（）方法可以当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕
get（long timeout,TimeUnit unit）做多等待timeout的时间就会返回结果
cancel（boolean mayInterruptIfRunning）方法可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），则可以返回true,如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false.
isDone（）方法判断当前方法是否完成
isCancel（）方法判断当前方法是否取消
RunnableFuture
该接口同时 extends Runnable, Future接口,由于run()方法没有返回值(void),可以通过Future访问执行结果.该接口的实现类是TutureTask,一个可以取消的异步计算,它实现了启动和取消一个计算,get方法查询计算结果时如果没有计算完成会阻塞.
SchedualFuture
这个接口表示一个延时的行为可以被取消。通常一个安排好的future是定时任务SchedualedExecutorService的结果
CompleteFuture
一个Future类是显示的完成，而且能被用作一个完成等级，通过它的完成触发支持的依赖函数和行为。当两个或多个线程要执行完成或取消操作时，只有一个能够成功。
ForkJoinTask
基于任务的抽象类，可以通过ForkJoinPool来执行。一个ForkJoinTask是类似于线程实体，但是相对于线程实体是轻量级的。大量的任务和子任务会被ForkJoinPool池中的真实线程挂起来，以某些使用限制为代价。
原始使用方式:
public class BumThread extends Thread{
@Override public void run() {
try {
Thread.sleep(1000*3); System.out.println("包子准备完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class ColdDishThread extends Thread{
@Override public void run() {
try {
Thread.sleep(1000); System.out.println("凉菜准备完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
// 等凉菜 -- 必须要等待返回的结果，所以要调用join方法
Thread t1 = new ColdDishThread(); t1.start(); t1.join();
// 等包子 -- 必须要等待返回的结果，所以要调用join方法
Thread t2 = new BumThread();
t2.start();
t2.join();
long end = System.currentTimeMillis();
System.out.println("准备完毕时间："+(end-start));
}
使用Callable+Future获取执行结果:
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
// 等凉菜
Callable ca1 = new Callable(){
@Override public String call() throws Exception {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "凉菜准备完毕";
}
};
FutureTask<String> ft1 = new FutureTask<String>(ca1);
new Thread(ft1).start();
// 等包子
Callable ca2 = new Callable(){
@Override public Object call() throws Exception {
try {
Thread.sleep(1000*3);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "包子准备完毕";
}
};
FutureTask<String> ft2 = new FutureTask<String>(ca2);
new Thread(ft2).start();
System.out.println(ft1.get());
System.out.println(ft2.get());
long end = System.currentTimeMillis(); System.out.println("准备完毕时间："+(end-start));
}
总结:
在没有这三个类以前,只有Thread和Runnable孤独的存在,两个人使用都不下蛋....
java在1.5提供Callable,实际上就是为了弥补Runnable的缺陷,增加了返回值.
然后为了兼容Runnable,,,单独定义提供了Future接口,
让我们在使用的时候可以通过它的唯一实现类FutureTask可以执行Runnable或者Callable来获取返回值.
也就是日常使用时FutureTask是结合它们两者共同完成多线程调用的工作.
