Future、Callable和Executor

案例：
从一个很大的数字数组中找到最大值，将工作分配给多个线程

public class FindMaxTask implements Callable<Integer> {
    private int[] data;
    private int start;
    private int end;

    public FindMaxTask(int[] data,int start,int end){
        this.data = data;
        this.start = start;
        this.end = end;
    }
    @Override
    public Integer call() throws Exception {
        int  max = Integer.MIN_VALUE;
        for(int i = start;i<end;i++){
            if(data[i] > max)
                max = data[i];
        }
        return max;
    }
}

public class MultiThreadedMaxFinder {
    public static int max(int[] data) throws ExecutionException, InterruptedException {
        if(data.length == 1){
            return data[0];
        }else if(data.length == 0){
            throw new IllegalArgumentException();
        }

        FindMaxTask task1 = new FindMaxTask(data,0,data.length/2);
        FindMaxTask task2 = new FindMaxTask(data,data.length/2,data.length);

        ExecutorService service = Executors.newFixedThreadPool(2);
        Future<Integer> future1 = service.submit(task1);
        Future<Integer> future2 = service.submit(task2);

        return Math.max(future1.get(),future2.get());
    }
}

将callable对象提交给一个Executor，他会为每个Callable对象创建一个线程

调用future1.get()方法会阻塞，等待第一个FindMaxTask完成，只有当第一个FindMaxTask完成时，才会调用future2.get()

Future是一种非常方便的做法，可以启动多个线程处理一个问题的不同部分