1.接口的定义：
|
1
2
3
4
|
|
2.callable和runnable的异同
先看下runnable接口的定义
|
1
2
3
|
public interface runnable {
public abstract void run();
}
|
callable的call()方法类似于runnable接口中run()方法，都定义任务要完成的工作，实现这两个接口时要分别重写这两个方法，主要的不同之处是call()方法是有返回值的（其实还有一些区别，例如call方法可以抛出异常，run方法不可以），运行callable任务可以拿到一个future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
3. callable类型的任务可以有两种执行方式：
我们先定义一个callable任务mycallabletask:
|
1
2
3
4
5
6
7
8
9
10
11
|
class mycallabletask implements callable<integer>{
@override
public integer call() throws exception {
system.out.println("线程在进行计算");
thread.sleep(3000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}
|
①借助futuretask执行
futuretask类同时实现了两个接口，future和runnable接口，所以它既可以作为runnable被线程执行，又可以作为future得到callable的返回值。
借助futuretask执行的大体流程是：
|
1
2
3
|
callable<integer> mycallabletask = new mycallabletask();
futuretask<integer> futuretask= new futuretask<integer>(mycallabletask);
new thread(futuretask).start();
|
通过futuretask可以得到mycallabletask的call()的运行结果： futuretask.get();
②借助线程池来运行
线程池中执行callable任务的原型例如：
|
1
2
3
4
5
6
7
|
public interface executorservice extends executor {
//提交一个callable任务，返回值为一个future类型
<t> future<t> submit(callable<t> task);
//other methods...
}
|
借助线程池来运行callable任务的一般流程为：
|
1
2
|
executorservice exec = executors.newcachedthreadpool();
future<integer> future = exec.submit(new mycallabletask());
|
通过future可以得到mycallabletask的call()的运行结果： future.get();
在网上看到了几个比较好的代码例子：
a.callable任务借助futuretask运行：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class callableandfuturetask {
public static void main(string[] args) {
callable<integer> callable = new callable<integer>() {
public integer call() throws exception {
return new random().nextint(100);
}
};
futuretask<integer> future = new futuretask<integer>(callable);
new thread(future).start();
try {
thread.sleep(5000);
system.out.println(future.get());
} catch (interruptedexception e) {
e.printstacktrace();
} catch (executionexception e) {
e.printstacktrace();
}
}
}
|
b.callable任务和线程池一起使用，然后返回值是future:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class callableandfuture {
public static void main(string[] args) {
executorservice threadpool = executors.newsinglethreadexecutor();
future<integer> future = threadpool.submit(new callable<integer>() {
public integer call() throws exception {
return new random().nextint(100);
}
});
try {
thread.sleep(5000);// 可能做一些事情
system.out.println(future.get());
} catch (interruptedexception e) {
e.printstacktrace();
} catch (executionexception e) {
e.printstacktrace();
}
}
}
|
c.当执行多个callable任务，有多个返回值时，我们可以创建一个future的集合，例如：
|
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
32
33
34
35
36
37
38
39
|
class mycallabletask implements callable<string> {
private int id;
public onetask(int id){
this.id = id;
}
@override
public string call() throws exception {
for(int i = 0;i<5;i++){
system.out.println("thread"+ id);
thread.sleep(1000);
}
return "result of callable: "+id;
}
}
public class test {
public static void main(string[] args) {
//callable<string> mycallabletask = new mycallabletask(1);
executorservice exec = executors.newcachedthreadpool();
arraylist<future<string>> results = new arraylist<future<string>>();
for (int i = 0; i < 5; i++) {
results.add(exec.submit(new mycallabletask(i)));
}
for (future<string> fs : results) {
if (fs.isdone()) {
try {
system.out.println(fs.get());
} catch (exception e) {
e.printstacktrace();
}
} else {
system.out.println("mycallabletask任务未完成！");
}
}
exec.shutdown();
}
}
|
①可以获得任务执行返回值；
②通过与future的结合，可以实现利用future来跟踪异步计算的结果。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持快网idc。
原文链接：https://blog.csdn.net/sunp823/article/details/51569314
相关文章
- 个人网站服务器域名解析设置指南：从购买到绑定全流程 2025-06-10
- 个人网站搭建：如何挑选具有弹性扩展能力的服务器？ 2025-06-10
- 个人服务器网站搭建：如何选择适合自己的建站程序或框架？ 2025-06-10
- 64M VPS建站：能否支持高流量网站运行？ 2025-06-10
- 64M VPS建站：怎样选择合适的域名和SSL证书？ 2025-06-10
