Java多线程（二）——Callable、Future和FutureTask

在上一章节我们介绍了Java实现多线程最常用的两种方式，但是那两种方式实现线程的时候并不能返回线程的执行结果。然而有些场景我们需要得到线程的执行结果，比如要计算每个部门的这个月的工资，然后进行总计（假设有n个部门，计算每个部门的工资需要花费m个小时，计算总计需要k个小时）。那么有以下两种方案供选择“：

1. n个部门工资计算和总计都安排给一个人来做，需要花费n*m+k小时；
2. 每个部门工资计算都分别安排给一个人来做（同时进行），最后一个人做统计工作，那么需要花费m+k小时即可；

方案一采用顺序执行的方式来做，需要花费的时间比较长；方案二采用执行并行的方式来做，在短时间内会花费更多的资源，但是节省了时间。方案一比较简单，在这里就不多赘述。让我们看下如何使用多线程的方式来实现方案二。

方案二的实现其实也很简单，无法是在多线程的基础上加上线程执行结果返回，Java中提供了Callable、Future和FutrueTask相关工具来协助我们实现，接下来就看下是如何实现的吧！

• Callable+Future实现：

//首先实现一个计算工资的Task类 并实现Callable接口 （线程返回结果类型即泛型填充类型）
 public class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("部门："+ Thread.currentThread().getId()+"正在计算工资");
        Random random = new Random();
        Thread.sleep(2000);//模拟工资计算耗时
        Integer sum = random.nextInt(100000);
        System.out.println("部门："+ Thread.currentThread().getId()+"计算完成。结果："+sum);
        return sum;
    }
}

//执行任务计算Main
public class Main {

    public static void main(String []args){
        //创建固定的线程数的线程池，不了解线程池的可以去了解下
        ExecutorService pool = Executors.newFixedThreadPool(5);

        Task task1 = new Task();
        Task task2 = new Task();
        Task task3 = new Task();
        Task task4 = new Task();
        Task task5 = new Task();

        long protime = System.currentTimeMillis();
        //将五个部门的工资计算交由线程池中的线程执行
        Future<Integer> result1 = pool.submit(task1);
        Future<Integer> result2 = pool.submit(task2);
        Future<Integer> result3 = pool.submit(task3);
        Future<Integer> result4 = pool.submit(task4);
        Future<Integer> result5 = pool.submit(task5);

        Integer sum = 0;
        //获取根据submit提交返回的类型为Future<Integer>类型的result获取线程执行结果（线程任务没执行完的话，在调用get方法的时会wait等待结果执行完成）
        try {
            sum += result1.get();
            sum += result2.get();
            sum += result3.get();
            sum += result4.get();
            sum += result5.get();
        } catch (InterruptedException e){       
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        long time = System.currentTimeMillis()-protime;
        System.out.println("总计需发工资："+sum+" 耗时："+time);
    }
}

• Callable+FutureTask实现：

//首先实现一个计算工资的Task类 并实现Callable接口 （线程返回结果类型即泛型填充类型）
 public class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("部门："+ Thread.currentThread().getId()+"正在计算工资");
        Random random = new Random();
        Thread.sleep(2000);//模拟工资计算耗时
        Integer sum = random.nextInt(100000);
        System.out.println("部门："+ Thread.currentThread().getId()+"计算完成。结果："+sum);
        return sum;
    }
}

public class Main {
    public static void main(String []args){
        ExecutorService pool = Executors.newFixedThreadPool(5);

        /**
        FutureTask实现了RunnableFuture接口， RunnableFuture接口实现Runnable和Future接口
        FutureTask相当于线程和结果的结合
        */
        FutureTask<Integer> futureTask1 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask2 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask3 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask4 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask5 = new FutureTask<>(new Task());

        long protime = System.currentTimeMillis();
        pool.submit(futureTask1);
        pool.submit(futureTask2);
        pool.submit(futureTask3);
        pool.submit(futureTask4);
        pool.submit(futureTask5);
        pool.shutdown();

        Integer sum = 0;
        try {
            sum += futureTask1.get();
            sum += futureTask2.get();
            sum += futureTask3.get();
            sum += futureTask4.get();
            sum += futureTask5.get();
        } catch (InterruptedException e){       
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        long time = System.currentTimeMillis()-protime;
        System.out.println("总计需发工资："+sum+" 耗时："+time);
    }
}

两种方式实现的执行效果基本一样（排除随机等因素）：

由结果分析，5个线程同时执行，大概计算2s后，相继计算出结果结果，耗时大概2s。

总结：
future模式在Java多线程的用处还是蛮大的，尤其是在做并行计算的场景下。Java为我们提供了相关工具，所以实现难度也不大，加以练习就会很容易掌握。但是为了深刻理解future模式以及实现原理，下一章节会来手动实现future模式，敬请期待！！！（文章中如有描述不明确或不正确的地方，欢迎大家批评指正，谢谢）。