Future and Callable

有的时候我们需要将一个问题分解成若干的小问题，假如每个小问题可以独立运算，运算后将结果进行合并， 这样的话我们可以使用多个线程处理每一个小问题后，将每个运算结果合并，这样可以极大的发挥计算机的性能，缩短运算时间，Java中提供者这样两个接口 Callable和Future，可以最大程度的简化上述问题的开发过程。

先来看一下Callable接口，Callable接口类似 Runnable，都是为了能被另一个线程执行而设计的，Callable与Runnable不同，Callable可以返回一个运行结 果，Runnable则不会返回，且Runnable不会抛出与各经过检查的异常。Callable包含一个类似Runnable的方法：

public <V> call() throws Exception;

这个方法用法和Runnable的run的用法一致，所不同的是其增加了返回值，并且允许抛出异常。

Future 接口表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。

下面的例子展示了如何使用Future、Callable和Executor完成求1-100以内和：

MyCallable.class

package net.chinaideal.concurrency.callable;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Long> {

    private Long start; 
    private Long end;

    public MyCallable(Long start, Long end) { 
        this.start = start; 
        this.end = end; 
    }

    @Override 
    public Long call() throws Exception { 
        long sum = 0; 
        for (long i = start; i <= end; i++) { 
            sum += i; 
        }

        System.out.println(Thread.currentThread().getName() + " " + start 
                + " - " + end + " = " + sum);

        return sum; 
    } 
}

CallableFutures.class:

package net.chinaideal.concurrency.callable;

import java.util.ArrayList; 
import java.util.List; 
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 CallableFutures { 
    private static final int NTHREDS = 10;

    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(NTHREDS); 
        List<Future<Long>> list = new ArrayList<Future<Long>>(); 
        for (long i = 0; i < NTHREDS; i++) { 
            Callable<Long> worker = new MyCallable(i * NTHREDS + 1, (i + 1) 
                    * NTHREDS); 
               Future<Long> submit = executor.submit(worker); 
            list.add(submit); 
        } 
        long sum = 0; 
        for (Future<Long> future : list) { 
            try { 
                sum += future.get(); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } catch (ExecutionException e) { 
                e.printStackTrace(); 
            } 
        }

        executor.shutdown(); 
        while (executor.isTerminated()) { 
        } 
        System.out.println("sum=" + sum);

    }

}

Callable中定义了两个成员变量start和end，分别代表运算的起始值和终止值，每一个线程需要完成的从start至end之和的运算。

通过调用ExecutorService.submit方法提交Callable任务，此方法返回一个Future对象，这个Future对象代表对应Callable返回的值，最后再将全部的Future求和完成对全部Callable结果的合并。