多线程之Runnable,Callable,Future,FutureTask

一：Runnable与Callable的区别

1. 需要实现的方法不同

实现Runnable接口需要实现run方法

<span style="font-size:14px;">public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see     java.lang.Thread#run()
*/
public abstract void run();
}</span>

实现Callable接口需要实现call方法

<span style="font-size:14px;">public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}</span>

2.  Runnable接口的run()方法没有返回值，而Callable接口的call()方法有返回值

获取Callable的call方法的放回结果是通过Future.get()来获取，Future模式是一种多线程设计模式中(详细可参

考：多线程设计模式读书笔记)，即在主线程中可以获取子线程的运行结果，但该结果是异步返回的。主线程通过调

用future.get()来获取子线程的执行结果，如果子线程还没有运行完，则该操作会被阻塞，直到子线程执行完或者抛

出异常。

<span style="font-size:14px;">public V get() throws InterruptedException, ExecutionException {
await();//阻塞住

Throwable cause = cause();
if (cause == null) {
return getNow();
}
throw new ExecutionException(cause);
}</span>

3. 使用方法不同

实现Runnable接口的任务可以传递给Thread(new Runnable())来执行，也可以通过线程池ExecutorService来使

用；而实现Callable接口的任务只能通过线程池ExecutorService来使用。

下面是一个实现Callable接口来进行算术运算并获取计算结果的例子：

<span style="font-size:14px;">public class CalculThread  {

private int count = 0;

private Task task;

public CalculThread(int count){
this.task = new Task(this);
this.count = count;
}

public void start(){
ExecutorService exector = Executors.newFixedThreadPool(1);
Future<Integer> result = exector.submit(task);
try {
System.out.println("计算结果："+result.get());//阻塞直到计算完成，或者发生异常
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

private int calcul(int num) throws InterruptedException{
int result = 0;
for(int i = 1; i<=num; i++){
Thread.sleep(1000);
result = result + i;
}
return result;
}

private class Task implements Callable<Integer>{

private CalculThread thread;

public Task(CalculThread thread){
this.thread = thread;
}

@Override
public Integer call() throws Exception {
return thread.calcul(thread.count);
}

}
}</span>

主线程:

<span style="font-size:14px;">public class MainThread {

public static void main(String[] args) {
CalculThread thread = new CalculThread(10);
thread.start();
}
}</span>

二：Future

Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java多线程设计模式Future模式

的实现，可以进行异步计算并获取计算结果。Future模式的详细介绍可参考文章：多线程设计模式读书笔记。

Future接口是一个泛型接口，格式为Future<V>，其中V代表了Future执行任务返回值的类型。

<span style="font-family:FangSong_GB2312;font-size:18px;">public interface Future<V> </span>

Future接口主要方法：

1. boolean cancel(boolean mayInterruptIfRunning)

尝试取消任务的执行，参数指定是立即中断任务的执行还是等待正在执行的任务结束。

2. boolean isCancelled()

任务是否已经取消，任务正常完成前将其取消，返回true

3. boolean isDone()

任务是否已经完成。如果任务正常终止，发生异常或者取消，均返回ture

4. V get() InterruptedException, ExecutionException

等待任务执行结束，然后获取V类型的返回结果。如果在get()过程中线程被异常中断，则抛出

InterruptedException，如果执行出现异常，则抛ExecutionException

5. V get(long timeout, TimeUnit unit)  throws InterruptedException, ExecutionException, 

TimeoutException

与get()功能一样，多了个超时时间。参数timeout指定超时时间，unit指定时间的单位。如果超时，将抛出

TimeoutExecption异常。

Future的使用方法可参考上面关于Callable使用的例子。

三：FutureTask

FutureTask实现了RunnableFuture接口，与Runnable，Future之间的关系如下图：



可以看出FutureTask是一个复合体，它具有Runnable的属性，可以传递给Thread来直接运行，也可以提交给

ExecuteService来执行；又具有Future的属性，可以通过FutureTask的get()方法来获取执行结果，如果线程没有执

行完成的时候，主线程在获取结果过程中一直阻塞等待。

FutureTask的主要方法

1.public FutureTask(Callable<V> callable) 

Callable接口作为入参构造FutureTask

2.public FutureTask(Runnable runnable, V result) 

Runnable接口和返回结果类型作为入参构造FutureTask

3.protected void set(V v) 

设置线程执行完成的结果到FutureTask中

4. protected void setException(Throwable t) 

如果线程运行异常，则将异常设置到FutureTask中

测试案例

FutureTask使用案例1

任务类

<span style="font-size:14px;">public class Task implements Callable<String> {

@Override
public String call() throws Exception {
return print();
}

private String print() throws InterruptedException {
System.out.println("子线程开始执行计算任务");
// TODO
Thread.sleep(5 * 1000);
return "wrold";
}
}</span>

主线程：

<span style="font-size:14px;">public class FutureTaskDemo {

public static void main(String[] args) throws InterruptedException,ExecutionException {
FutureTask<String> futureTask = new FutureTask<String>(new Task());
Thread thread = new Thread(futureTask);
thread.start();
System.out.println("主线程计算开始...");
Thread.sleep(2 * 1000);
// TODO主线程的计算任务
System.out.println("主线程计算结束...");
while (!futureTask.isDone()) {
System.out.println("子线程计算还未完成，请等待...");
Thread.sleep(500);
}
System.out.println("子线程计算完成，计算结果" + futureTask.get());
}
}</span>

执行结果

主线程计算开始...

子线程开始执行计算任务

主线程计算结束...

子线程计算还未完成，请等待...

子线程计算还未完成，请等待...

子线程计算还未完成，请等待...

子线程计算还未完成，请等待...

子线程计算还未完成，请等待...

子线程计算还未完成，请等待...

子线程计算还未完成，请等待...

子线程计算完成，计算结果wrold

FutureTask使用案例2

该例子展示如何将一个任务分派给多个子线程去去完成，并且最后将各个子线程的运算结果汇总起来

<span style="font-size:14px;">public class ConcurrentCalculator {

private ExecutorService exec;
private int cpuCoreNumber;
private List<Future<Long>>tasks=new ArrayList<Future<Long>>();

class SumCalculator implements Callable<Long>{
private int[] numbers;
private int start;
private int end;

public SumCalculator(final int[] numbers, int start, int end) {
this.numbers=numbers;
this.start=start;
this.end=end;
}

@Override
public Long call() throws Exception {
Long sum=0l;
for (int i=start;i <end;i++) {
sum += numbers[i];
}
return sum;
}
}

public ConcurrentCalculator() {
cpuCoreNumber=Runtime.getRuntime().availableProcessors();
exec=Executors.newFixedThreadPool(cpuCoreNumber);
}

public Long sum(final int[] numbers) {
// 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor
for (int i=0;i <cpuCoreNumber;i++) {
int increment=numbers.length / cpuCoreNumber + 1;
int start=increment * i;
int end=increment * i + increment;
if (end >numbers.length)
end=numbers.length;
SumCalculator subCalc=new SumCalculator(numbers, start, end);
FutureTask<Long>task=new FutureTask<Long>(subCalc);
tasks.add(task);
if (!exec.isShutdown()) {
exec.submit(task);
}
}
return getResult();
}

/**
* 迭代每个只任务，获得部分和，相加返回
*
* @return
*/
public Long getResult() {
Long result=0l;
for (Future<Long>task : tasks) {
try {
// 如果计算未完成则阻塞
Long subSum=task.get();
result += subSum;
}catch (InterruptedException e) {
e.printStackTrace();
}catch (ExecutionException e) {
e.printStackTrace();
}
}
return result;
}

public void close() {
exec.shutdown();
}

public static void main(String[] args){
int[] numbers=new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
ConcurrentCalculator calc=new ConcurrentCalculator();
Long sum=calc.sum(numbers);
System.out.println(sum);
calc.close();
}
} </span>