Java Concurrency 简明教程

Java Concurrency - Futures and Callables

java.util.concurrent.Callable 对象可以返回由线程完成的计算结果,而 runnable 接口只能运行该线程。 Callable 对象返回 Future 对象,该对象提供用于监视线程执行的任务进度的的方法。 Future 对象可用于检查 Callable 的状态,然后在线程完成后从 Callable 中检索结果。它还提供了超时功能。

Syntax

//submit the callable using ThreadExecutor
//and get the result as a Future object
Future<Long> result10 = executor.submit(new FactorialService(10));

//get the result using get method of the Future object
//get method waits till the thread execution and then return the result of the execution.
Long factorial10 = result10.get();

Example

以下 TestThread 程序展示了在基于线程的环境中使用 Future 和 Callable。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException,
      ExecutionException {

      ExecutorService executor = Executors.newSingleThreadExecutor();

      System.out.println("Factorial Service called for 10!");
      Future<Long> result10 = executor.submit(new FactorialService(10));

      System.out.println("Factorial Service called for 20!");
      Future<Long> result20 = executor.submit(new FactorialService(20));

      Long factorial10 = result10.get();
      System.out.println("10! = " + factorial10);

      Long factorial20 = result20.get();
      System.out.println("20! = " + factorial20);

      executor.shutdown();
   }

   static class FactorialService implements Callable<Long> {
      private int number;

      public FactorialService(int number) {
         this.number = number;
      }

      @Override
      public Long call() throws Exception {
         return factorial();
      }

      private Long factorial() throws InterruptedException {
         long result = 1;

         while (number != 0) {
            result = number * result;
            number--;
            Thread.sleep(100);
         }
         return result;
      }
   }
}

这将产生以下结果。

Output

Factorial Service called for 10!
Factorial Service called for 20!
10! = 3628800
20! = 2432902008176640000