可调用（Callable）接口表示可以返回值的线程。
除了它可以返回一个值之外，它非常类似于可运行的接口。
可调用的接口可用于计算可以返回给调用线程的状态或者结果。
例如：假设我们想要执行某些数字的因子和平方，我们可以使用可调用接口同时进行，这也将返回值。
可调用的只定义了一种如下方法

public interface Callable {
V call() throws Exception;
 
}

我们可以定义要在调用方法中执行的任务。
如果它成功执行，则调用方法将返回它必须抛出异常的结果。
我们可以使用ExecutorService的提交来执行可调用的任务。
让我们在ExecutorService中查看提交方法的签名。

Future submit(Callable task);

如果我们注意到，返回类型的提交方式是未来。

将来是通用接口，代表可通过可调用接口返回的值。
随着Callable将在未来的时间内返回值，姓名似乎是合适的。

有两种方法可以从将来获得实际价值。

get()：调用此方法时，线程将无限期等待结果。

v get(长超时，时间单位)：调用此方法时，线程将仅在指定时间等待结果。

例子：

该计划将展示使用可调用和未来。
我们将创建一个可调用的正方形和一个可递议的阶乘来计算。
我们将向执行的四个任务向Executorservice提交四个方形和25分的阶段。
该计划将展示如何利用可调用和未来同时执行它。

创建名为PowerCalc的类，它实现可调用接口。

package org.igi.theitroad;
import java.util.concurrent.Callable;
public class PowerCalc implements Callable{
private double number;
 
 PowerCalc(double number)
 
public Double call() throws Exception {
{
  this.number=number;
 }
 
 @Override
System.out.println("Calculating Square with "+Thread.currentThread().getName());
Thread.sleep(2000);
  return Math.pow(number, number);
 }
 
}

创建另一个名为factoriairation的类，它可以实现可调用的接口。

package org.igi.theitroad;
 
import java.util.concurrent.Callable;
 
public class FactorialCalc implements Callable {
 
private double number;
 
 FactorialCalc(double number) {
public Double call() throws Exception {
 
this.number = number;
 }
 
 @Override
System.out.println("Calculating factorial with "+Thread.currentThread().getName());
Thread.sleep(5000);
  double fact = 1;
  for (int i = 2; i <= number; i++) {
   fact *= i;
  }
  return fact;
 }
}

现在创建一个名为futurecallablemain.java的主要类。

package org.igi.theitroad;
 
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.Executors;
 
public class FutureCallableMain {
 
 
ExecutorService es=Executors.newFixedThreadPool(4);
public static void main(String[] args) {
  System.out.println("Start : ");
  Future powerFuture20;
 
powerFuture20=es.submit(new PowerCalc(20));
Future factorialFuture20;
  Future powerFuture25;
  Future factorialFuture25;
 
factorialFuture25=es.submit(new FactorialCalc(25));
factorialFuture20=es.submit(new FactorialCalc(20));
  powerFuture25=es.submit(new PowerCalc(25));
   try {
System.out.println("Square of "+25+" : "+powerFuture25.get());
System.out.println("Square of "+20+" : "+powerFuture20.get());
    System.out.println("Factorial of "+20+" : "+factorialFuture20.get());
 
es.shutdown();
System.out.println("Factorial of "+25+" : "+factorialFuture25.get());
   } catch (InterruptedException | ExecutionException e) {
  
    e.printStackTrace();
   } 
  System.out.println("Done");
 }
 
}

运行上面的程序时，我们将得到以下输出：

Start : 
Calculating Square with pool-1-thread-1
Calculating factorial with pool-1-thread-2
Calculating Square with pool-1-thread-3
Square of 20 : 1.048576E26
Calculating factorial with pool-1-thread-4
Factorial of 20 : 2.43290200817664E18
Done
Square of 25 : 8.881784197001253E34
Factorial of 25 : 1.5511210043330986E25