Java多线程之Callable接口的实现

Java多线程之Callable接口的实现

1.接口的定义：

public interface Callable

{

V call() throws Exception;

}

2.Callable和Runnable的异同

先看下Runnable接口的定义

public interface Runnable {

public abstract void run();

}

Callable的call()方法类似于Runnable接口中run()方法，都定义任务要完成的工作，实现这两个接口时要分别重写这两个方法，主要的不同之处是call()方法是有返回值的（其实还有一些区别，例如call方法可以抛出异常，run方法不可以），运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

3. Callable类型的任务可以有两种执行方式：

我们先定义一个Callable任务MyCallableTask:

class MyCallableTask implements Callable{

@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执行的大体流程是：

Callable mycallabletask = new MyCallableTask();

FutureTask futuretask= new FutureTask(mycallabletask);

new Thread(futuretask).start();

通过futuretask可以得到MyCallableTask的call()的运行结果： futuretask.get();

②借助线程池来运行

线程池中执行Callable任务的原型例如：

public interface ExecutorService extends Executor {

//提交一个Callable任务，返回值为一个Future类型

Future submit(Callable task);

//other methods...

}

借助线程池来运行Callable任务的一般流程为：

ExecutorService exec = Exechttp://utors.newCachedThreadPool();

Future future = exec.submit(new MyCallableTask());

通过future可以得到MyCallableTask的call()的运行结果： future.get();

在网上看到了几个比较好的代码例子：

a.Callable任务借助FutureTask运行：

public class CallableAndFutureTask {

public static void main(String[] args) {

Callable() {

public Integer call() throws Exception {

return new Random().nextInt(100);

}

};

FutureTask future = new FutureTask(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:

public class CallableAndFuture {

public static void main(String[] args) {

ExecutorService threadPool = Executors.newSingleThreadExecutor();

Future future = threadPool.submit(new Callable() {

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的集合，例如：

class MyCallableTask implements Callable {

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 mycallabletask = new MyCallableTask(1);

ExecutorService exec = Executors.newCachedThreadPool();

ArrayList> results = new ArrayList>();

for (int i = 0; i < 5; i++) {

results.add(exec.submit(new MyCallableTask(i)));

}

for (Future fs : results) {

if (fs.isDone()) {

try {

System.out.println(fs.get());

} catch (Exception e) {

e.printStackTrace();

}

} else {

System.out.println("MyCallableTask任务未完成！");

}

}

exec.shutdown();

}

}

那么引入Callable接口具有哪些好处呢？

①可以获得任务执行返回值；

②通过与Future的结合，可以实现利用Future来跟踪异步计算的结果。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。