怎么在Java中利用多线程实现一个Callable接口

今天就跟大家聊聊有关怎么在Java中利用多线程实现一个Callable接口，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。

成都创新互联公司是一家集成都网站建设、成都网站制作、网站页面设计、网站优化SEO优化为一体的专业的建站公司，已为成都等多地近百家企业提供网站建设服务。追求良好的浏览体验,以探求精品塑造与理念升华,设计最适合用户的网站页面。 合作只是第一步，服务才是根本,我们始终坚持讲诚信，负责任的原则，为您进行细心、贴心、认真的服务,与众多客户在蓬勃发展的市场环境中,互促共生。

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 = Executors.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 callable = new 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来跟踪异步计算的结果。

看完上述内容，你们对怎么在Java中利用多线程实现一个Callable接口有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。