[置顶] Java多线程（二）——Callable、Future和FutureTask

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

n个部门工资计算和总计都安排给一个人来做，需要花费n*m+k小时；

每个部门工资计算都分别安排给一个人来做（同时进行），最后一个人做统计工作，那么需要花费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模式，敬请期待！！！（文章中如有描述不明确或不正确的地方，欢迎大家批评指正，谢谢）。