【Java线程】Callable和Future

Future模式

Future接口是Java线程Future模式的实现，可以来进行异步计算。

Future模式可以这样来描述：

我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。

就相当于下了一张订货单，一段时间后可以拿着提订单来提货，这期间可以干别的任何事情。其中Future接口就是订货单，真正处理订单的是Executor类，它根据Future接口的要求来生产产品。

Callable和Future接口

Callable接口

Callable和Future一个产生结果，一个拿到结果。

Callable接口类似于Runnable，但是Runnable不会返回结果，而Callable可以返回结果，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值。

  • V call()
  1. /**
  2. * Computes a result, or throws an exception if unable to do so.
  3. *
  4. * @return computed result
  5. * @throws Exception if unable to compute a result
  6. */
  7. V call() throws Exception;

Future接口

Future 表示异步计算的结果。Future接口中有如下方法：

  • boolean cancel(boolean mayInterruptIfRunning)

取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束

  • boolean isCancelled()

任务是否已经取消，任务正常完成前将其取消，则返回 true

  • boolean isDone()

任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true

  • V get()

等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException

  • V get(long timeout, TimeUnit unit)

同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException

Future接口提供方法来检测任务是否被执行完，等待任务执行完获得结果。也可以设置任务执行的超时时间，这个设置超时的方法就是实现Java程序执行超时的关键。

所以，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。

  1. int result = future.get(5000, TimeUnit.MILLISECONDS);

Future实现类：SwingWorker

SwingWorker的用法

http://blog.csdn.net/vking_wang/article/details/8994882

Future实现类：FutureTask

Future的实现类有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask来处理我们的任务。

FutureTask类同时又实现了Runnable接口，所以可以直接提交给Thread、Executor执行。

  1. public class CallableAndFuture {
  2. public static void main(String[] args) {
  3. Callable<Integer> callable = new Callable<Integer>() {
  4. public Integer call() throws Exception {
  5. return new Random().nextInt(100);
  6. }
  7. };
  8. FutureTask<Integer> future = new FutureTask<Integer>(callable);
  9. new Thread(future).start();
  10. try {
  11. Thread.sleep(5000);// 可能做一些事情
  12. int result = future.get());
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. } catch (ExecutionException e) {
  16. e.printStackTrace();
  17. }
  18. }
  19. }

通过ExecutorService的submit方法执行Callable，并返回Future

使用ExecutorService：

  1. public class CallableAndFuture {
  2. public static void main(String[] args) {
  3. //ExecutorService.submit()
  4. ExecutorService threadPool = Executors.newSingleThreadExecutor();
  5. Future<Integer> future = threadPool.submit(new Callable<Integer>() {
  6. public Integer call() throws Exception {
  7. return new Random().nextInt(100);
  8. }
  9. });
  10. try {
  11. Thread.sleep(5000);// 可能做一些事情
  12. int result = future.get()); //Future.get()
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. } catch (ExecutionException e) {
  16. e.printStackTrace();
  17. }
  18. }
  19. }

如果要执行多个带返回值的任务，并取得多个返回值，可用CompletionService：

CompletionService相当于Executor加上BlockingQueue，使用场景为当子线程并发了一系列的任务以后，主线程需要实时地取回子线程任务的返回值并同时顺序地处理这些返回值，谁先返回就先处理谁。


  1. public class CallableAndFuture {
  2. public static void main(String[] args) {
  3. ExecutorService threadPool = Executors.newCachedThreadPool();
  4. CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(threadPool);
  5. for(int i = 1; i < 5; i++) {
  6. final int taskID = i;
  7. //CompletionService.submit()
  8. cs.submit(new Callable<Integer>() {
  9. public Integer call() throws Exception {
  10. return taskID;
  11. }
  12. });
  13. }
  14. // 可能做一些事情
  15. for(int i = 1; i < 5; i++) {
  16. try {
  17. int result = cs.take().get());  //CompletionService.take()返回Future
  18. } catch (InterruptedException e) {
  19. e.printStackTrace();
  20. } catch (ExecutionException e) {
  21. e.printStackTrace();
  22. }
  23. }
  24. }
  25. }

或者不使用CompletionService：先创建一个装Future类型的集合，用Executor提交的任务返回值添加到集合中，最后便利集合取出数据。

区别：

Future集合方法，submit的task不一定是按照加入自己维护的list顺序完成的。从list中遍历的每个Future对象并不一定处于完成状态，这时调用get()方法就会被阻塞住，如果系统是设计成每个线程完成后就能根据其结果继续做后面的事，这样对于处于list后面的但是先完成的线程就会增加了额外的等待时间。

而CompletionService的实现是维护一个保存Future对象的BlockingQueue。只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。它会从Queue中取出Future对象，如果Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。

所以，先完成的必定先被取出。这样就减少了不必要的等待时间。

时间： 2024-11-10 20:15:03

【Java线程】Callable和Future的相关文章

JDK5.0特性-线程 Callable和Future

来自:http://www.cnblogs.com/taven/archive/2011/12/17/2291466.html 1 import java.util.concurrent.Callable; 2 3 import java.util.concurrent.ExecutorService; 4 5 import java.util.concurrent.Executors; 6 7 import java.util.concurrent.Future; 8 9 10 11 /**

Java多线程 - Callable和Future

已知的创建多线程的方法有继承Tread类和实现Runnable方法.此外Java还提供了Callable接口,Callable接口也提供了一个call()方法来做为线程执行体.但是call()方法与run()方法有些不同: call()方法可以有返回值 call()方法可以抛出异常 不过Java不允许Callable对象直接作为Thread的target.而且call()方法还有一个返回值--call()方法并不是直接调用,他是做为线程执行体被调用的.Java提供了Future接口来代表Call

Java并发——Callable和Future

Callable和Future Executor框架将工作单元划分为任务,即任务是逻辑上的工作单元,而线程是任务异步执行的机制.Runnable是任务的一个抽象,并且理想状态下任务是独立的执行,但是Runnable的run( )不能返回一个结果或者抛出一个受检查的异常,这与我们有些实际任务是不相符的.在通过线程或者executor执行Runnable任务中,不仅仅是不能返回任务的执行结果,有时我们希望可以控制某个任务,或取消或终止,但在executor中一旦提交任务,我们将很难单一的控制任务的生

Java多线程——Callable与Future

二月份回家过年了,家里没网,所以博客也停了一段时间,上班已经一周了,总的来说还是比较忙吧!周末还是把没总结完的知识点总结一下,方便日后翻阅! Callable与Future Runnable封装一个异步运行的任务,可以把它想象成一个没有参数和返回值的异步方法.Callable与Runnable类似,但是有返回值.Callable接口是一个参数化的类型,只有一个方法call. public interface Callable<V>{ V call() throws Exception; } 类

java 使用Callable和Future返回线程执行的结果

我们可能在某些特殊的需求下需要返回一个线程执行的结果,在java 1.5提供了Callable和Futrue就能帮你实现!不解释看代码 package cn.kge.com; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Exe

Java利用Callable、Future进行并行计算求和

内容:在Java中利用Callable进行带返回结果的线程计算,利用Future表示异步计算的结果,分别计算不同范围的Long求和,类似的思想还能够借鉴到需要大量计算的地方. public class Sums { public static class Sum implements Callable<Long> { private final Long from; private final Long to; public Sum(long from, long to) { this.fro

Java多线程Callable和Future类详解

     public interface Callable<V>    返回结果并且可能抛出异常的任务.实现者定义了一个不带任何参数的叫做 call 的方法      public interface Future<V>      Future 表示异步计算的结果.计算完成后只能使用 get 方法来获取结果 1.线程处理返回结果 一般开发中,使用多线程,最常见的就是:1.实现Runnable接口:2.继承Thread类. 但是run方法是没有返回结果,很难满足我们的需求.这时,常

Java - &quot;JUC线程池&quot; Callable与Future

Java多线程系列--"JUC线程池"06之 Callable和Future Callable 和 Future 简介 Callable 和 Future 是比较有趣的一对组合.当我们需要获取线程的执行结果时,就需要用到它们.Callable用于产生结果,Future用于获取结果. 1. Callable Callable 是一个接口,它只包含一个call()方法.Callable是一个返回结果并且可能抛出异常的任务. 为了便于理解,我们可以将Callable比作一个Runnable接

Java多线程系列--“JUC线程池”06之 Callable和Future

概要 本章介绍线程池中的Callable和Future.Callable 和 Future 简介示例和源码分析(基于JDK1.7.0_40) 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3544116.html Callable 和 Future 简介 Callable 和 Future 是比较有趣的一对组合.当我们需要获取线程的执行结果时,就需要用到它们.Callable用于产生结果,Future用于获取结果. 1. Callable Calla

Java线程：线程安全类和Callable与Future(有返回值的线程)

一.线程安全类 当一个类已经很好的同步以保护它的数据时,这个类就称为线程安全的.当一个集合是安全的,有两个线程在操作同一个集合对象,当第一个线程查询集合非空后,删除集合中所有元素的时候,第二个线程也来执行与第一个线程相同的操作,也许第一个线程查询后,第二个也查出非空,但是此时明显是不对的.如: 1 public class NameList { 2 private List nameList = Collections.synchronizedList(new LinkedList()); 3