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结果的合并。

猜你喜欢