Java多线程之Callable接口的实现

1.接口的定义:

public interface Callable<V> { 
 	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对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。

  1. Callable类型的任务可以有两种执行方式:
    我们先定义一个Callable任务MyCallableTask:
public 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执行的大体流程是:

Callable<Integer> mycallabletask = new MyCallableTask(); 
FutureTask<Integer> futuretask= new FutureTask<Integer>(mycallabletask); 
new Thread(futuretask).start();

通过futuretask可以得到MyCallableTask的call()的运行结果: futuretask.get();
②借助线程池来运行
线程池中执行Callable任务的原型例如:

public interface ExecutorService extends Executor {
	 //提交一个Callable任务,返回值为一个Future类型
	 <T> Future<T> submit(Callable<T> task);
	 //other methods...
 }

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

ExecutorService exec = Executors.newCachedThreadPool();
Future<Integer> future = exec.submit(new MyCallableTask());

通过future可以得到MyCallableTask的call()的运行结果: future.get();
在网上看到了几个比较好的代码例子:
a.Callable任务借助FutureTask运行:

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:

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的集合,例如:

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(); 
 } 
}

4、那么引入Callable接口具有哪些好处呢?
①可以获得任务执行返回值;
②通过与Future的结合,可以实现利用Future来跟踪异步计算的结果。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值