Callable
Callable和rRunnable差不多,两者都是为那些其实例可能被另一个线程执行的类而设计的,最主要的差别在于Runnable不会返回线程运算结果,Callable可以(假如线程需要返回运行结果)
Future
Future是一个接口表示异步计算的结果,它提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果。Future提供了get()、cancel()、isCancel()、isDone()四种方法,表示Future有三种功能:
1、判断任务是否完成
2、中断任务
3、获取任务执行结果
FutureTask
FutureTask是Future的实现类,也可以说是进阶类,优化了Future的一些缺点,比如Future.get会阻塞等等,它提供了对Future的基本实现。可使用FutureTask包装Callable或Runnable对象,因为FutureTask实现了Runnable和Future(看源码可以看出来),所以也可以将FutureTask提交给Executor。一般使用FutureTask代替Future即可
使用方法
Callable、Future、FutureTask一般都是和线程池配合使用的,因为线程池ThreadPoolExecutor的父类AbstractExecutorService提供了三种submit方法:
1、public Future<?> subit(Runnable task){...}
2、public <T> Future<T> submit<Runnable task, T result>{...}
3、public <T> Future<T> submit<Callable<T> task>{...}
第2个用得不多,第1个和第3个比较有用
Callable+Future使用示例
public static class CallableThread implements Callable<String>
{
public String call() throws Exception
{
System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
Thread.sleep(10000);
return "123";
}
} public static void main(String[] args) throws Exception
{
ExecutorService es = Executors.newCachedThreadPool();
CallableThread ct = new CallableThread();
Future<String> f = es.submit(ct);
es.shutdown(); Thread.sleep(5000);
System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis()); String str = f.get();
System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
}
运行结果为:
进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1444654421368
主线程等待5秒, 当前时间为1444654426369
Future已拿到数据, str = 123, 当前时间为1444654431369
看到任意一个利用Callable接口submit上去的任务,只要有一个Future接受它,Future便可以在程序任何地点尝试去获取这条线程返回出去的数据,时间可以比对一下,正好10000ms,即10s
这里的 Future.get 是阻塞方法 , 会一直等待Callable中线程任务执行完毕,是很低下的效率,
解决方式
1.可以使用FutureTask ,重写done方法
2.循环判断isDone,返回true的时候然后调用get()获取
Callable+FutureTask使用示例
有兴趣的可以看下源码,其实使用Callable+Future的方式,es.submit(ct)方法返回的Future,底层实现new出来的是一个FutureTask。那么,我们看一下Callable+FutureTask的方式:
public static class CallableThread implements Callable<String>
{
public String call() throws Exception
{
System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
Thread.sleep(10000);
System.out.println("线程睡眠 10s完毕 返回 123");
return "123";
}
}
public static class MyFutureTask<String> extends FutureTask<String>{
public MyFutureTask(Callable callable) {
super(callable);
}
@Override
protected void done() {
super.done();
try {
String str = this.get();
System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService es = Executors.newCachedThreadPool();
CallableThread ct = new CallableThread();
MyFutureTask<String> f = new MyFutureTask<>(ct);
es.submit(f);
es.shutdown();
System.out.println("主线程执行完毕, 当前时间为" + System.currentTimeMillis());
}
执行结果
主线程执行完毕, 当前时间为1474276672135
进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1474276672135
线程睡眠 10s完毕 返回 123
Future已拿到数据, str = 123, 当前时间为1474276682135
可以看到通过FutureTask 构造传入 Callable 类, 重写 done 处理线程执行完毕之后的代码,和Future不同的是,FutureTask集成了Callable ,只需要传入一个Callable, 就可以在内部实现Callable完成后的处理,也不会占用main线程了
使用Callable、Future和FutureTask的好处
上面演示了两个例子,其实反映的是现实中一种情况,把上面的例子稍微扩展一下就是:
有一个method()方法,方法中执行方法A返回一个数据要10秒钟,A方法后面的代码一共要执行20秒钟,但是这20秒的代码中有10秒的方法并不依赖方法A的执行结果,有10秒钟的代码依赖方法A的执行结果。此时若采用同步的方式,那么势必要先等待10秒钟,等待方法A执行完毕,返回数据,再执行后面20秒的代码。
不得不说这是一种低效率的做法。有了Callable、Future和FutureTask,那么:
1、先把A方法的内容放到Callable实现类的call()方法中
2、method()方法中,Callable实现类传入Executor的submit方法中
3、执行后面方法中10秒不依赖方法A运行结果的代码
4、获取方法A的运行结果,执行后面方法中10秒依赖方法A运行结果的代码
这样代码执行效率一下子就提高了,程序不必卡在A方法处。
当然,也可以不用Callable,采用实现Runnable的方式,run()方法执行完了想个办法给method()方法中的某个变量V赋个值就好了。但是我上一篇文章开头就说了,之所以要用多线程组件,就是因为JDK帮我们很好地实现好了代码细节,让开发者更多可以关注业务层的逻辑。如果使用Runnable的方式,那么我们自己就要考虑很多细节,比如Runnable实现类的run()方法执行完毕给V赋值是否线程安全、10秒后如果A方法没有执行完导致V还没有值怎么办,何况JDK还给用户提供了取消任务、判断任务是否存在等方法。既然JDK已经帮我们考虑并实现这些细节了,在没有有说服力的理由的情况下,我们为什么还要自己写run()方法的实现呢?