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

使用Callable、Future进行并行编程

在Java中进行并行编程最经常使用的方式是继承Thread类或者实现Runnable接口。这两种方式的缺点是在任务完成后没法直接获取执行结果，必须经过共享变量或线程间通讯，使用起来很不方便。
从Java 1.5开始提供了Callable和Future两个接口，经过使用它们能够在任务执行完毕后获得执行结果。
下面咱们来学习下如何使用Callable、Future和FutureTask。

Callable接口

Callable接口位于java.util.concurrent包，这是一个泛型接口，里面只声明了一个call()方法：

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

通常配合ExecutorService接口来使用它，在ExecutorService接口中声明了几个重载的submit方法：

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

第一个submit方法里面的参数类型就是Callable，另外两个本文暂时不涉及。

Future和FutureTask

Future接口的实现类能够对Runnable或者Callable的任务执行取消、查询、获取结果的操做。
Future接口也位于java.util.concurrent包下：

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;
}

总结下来Future提供了三种功能：

• 判断任务是否完成
• 可以中断任务
• 可以获取任务执行的结果

JDK中为咱们提供了一个Future接口的实现类FutureTask，它有以下两个构造函数。

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

示例代码

1. 使用Callable、Future

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
全部任务执行完毕

1. 使用Callable、FutureTask

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全部任务执行完毕