浅谈在Java中使用Callable、Future进行并行编程

public interface Callable<T> {
  T call() throws Exception;
}

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

public interface Future<T> {
  /**
  *取消任务
  *@param mayInterruptIfRunning
  *是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务
  *如果任务正在执行，则返回true
  *如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，返回true
  *如果任务已经完成，则无论mayInterruptIfRunning为true还是false，返回false
  */
  boolean cancel(boolean mayInterruptIfRunning);
  /**
  *任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true
  */
  boolean isCancelled();
  /**
  *任务是否完成
  */
  boolean isDone();
  /**
  *通过阻塞获取执行结果
  */
  T get() throws InterruptedException, ExecutionException;
  /**
  *通过阻塞获取执行结果。如果在指定的时间内没有返回，则返回null
  */
  T get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException;
}

判断任务是否完成
能够中断任务
能够获取任务执行的结果

public FutureTask(Callable<T> callable) {
}
public FutureTask(Runnable runnable, T result) {
}

import java.util.concurrent.*;
public class Test {
  public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Task task = new Task();
    Future<Integer> future = executorService.submit(task);
    executorService.shutdown();
    
    System.out.println("主线程在执行任务...");
    try {
      Thread.sleep(2000);
    } catch(InterruptedException ex) {
      ex.printStackTrace();
    }
     
    try {
      System.out.println("task运行结果:"+future.get());
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    } catch (ExecutionException ex) {
      ex.printStackTrace();
    } 
    System.out.println("所有任务执行完毕");
  }
}
class Task implements Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    System.out.println("子线程在执行任务...");
    //模拟任务耗时
    Thread.sleep(5000);
    return 1000;
  }
}

子线程在执行任务...
主线程在执行任务...
task运行结果:1000
所有任务执行完毕

import java.util.concurrent.*;
public class Test {
  public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Task task = new Task();
    FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
    executorService.submit(futureTask);
    executorService.shutdown();
    
    System.out.println("主线程在执行任务...");
    try {
      Thread.sleep(2000);
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    }
     
    try {
      System.out.println("task运行结果:"+futureTask.get());
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    } catch (ExecutionException ex) {
      ex.printStackTrace();
    }
     
    System.out.println("所有任务执行完毕");
  }
}
class Task implements Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    System.out.println("子线程在执行任务...");
    //模拟任务耗时
    Thread.sleep(5000);
    return 1000;
  }
}

子线程在执行任务...
主线程在执行任务...
task运行结果:1000
所有任务执行完毕