* [Java中的Runnable、Callable、Future、FutureTask的区别与示例](第5章 多线程/Java中的Runnable、Callable、Future、FutureTask的区别与示例.md)

Java中存在Runnable、Callable、Future、FutureTask这几个与线程相关的类或者接口，在Java中也是比较重要的几个概念，我们通过下面的简单示例来了解一下它们的作用于区别。

其中Runnable应该是我们最熟悉的接口，它只有一个run()函数，用于将耗时操作写在其中，该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable的声明如下 :

public interface Runnable {

/**

*/

public abstract void run();

}

Callable与Runnable的功能大致相似，Callable中有一个call()函数，但是call()函数有返回值，而Runnable的run()函数不能将结果返回给客户程序。Callable的声明如下 :

public interface Callable<V> {

/**

*/

V call() throws Exception;

}

可以看到，这是一个泛型接口，call()函数返回的类型就是客户程序传递进来的V类型。

Executor就是Runnable和Callable的调度容器，Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞，直到任务返回结果(Future简介)。Future声明如下 :

*/

public interface Future<V> {

/**

*/

boolean cancel(boolean mayInterruptIfRunning);

/**

*/

boolean isCancelled();

/**

*/

boolean isDone();

/**

*/

V get() throws InterruptedException, ExecutionException;

/**

*/

V get(long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException;

}

FutureTask则是一个RunnableFuture&lt;V>，而RunnableFuture实现了Runnbale又实现了Futrue&lt;V>这两个接口，

public class FutureTask<V> implements RunnableFuture<V>

```

```java

public interface RunnableFuture<V> extends Runnable, Future<V> {

/**

*/

void run();

}

另外它还可以包装Runnable和Callable&lt;V>， 由构造函数注入依赖。

public FutureTask(Callable<V> callable) {

if (callable == null)

throw new NullPointerException();

this.callable = callable;

this.state = NEW; // ensure visibility of callable

}

public FutureTask(Runnable runnable, V result) {

this.callable = Executors.callable(runnable, result);

this.state = NEW; // ensure visibility of callable

}

可以看到，Runnable注入会被Executors.callable()函数转换为Callable类型，即FutureTask最终都是执行Callable类型的任务。该适配函数的实现如下 ：

public static <T> Callable<T> callable(Runnable task, T result) {

if (task == null)

throw new NullPointerException();

return new RunnableAdapter<T>(task, result);

}

RunnableAdapter适配器

*/

static final class RunnableAdapter<T> implements Callable<T> {

final Runnable task;

final T result;

RunnableAdapter(Runnable task, T result) {

this.task = task;

this.result = result;

}

public T call() {

task.run();

return result;

}

}

由于FutureTask实现了Runnable，因此它既可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行。并且还可以直接通过get()函数获取执行结果，该函数会阻塞，直到结果返回。因此FutureTask既是Future、Runnable，又是包装了Callable( 如果是Runnable最终也会被转换为Callable )， 它是这两者的合体。

简单示例

package com.effective.java.concurrent.task;

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;

import java.util.concurrent.FutureTask;

*/

public class RunnableFutureTask {

/**

*/

static ExecutorService mExecutor = Executors.newSingleThreadExecutor();

/**

*/

public static void main(String[] args) {

runnableDemo();

futureDemo();

}

/**

*/

static void runnableDemo() {

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("runnable demo : " + fibc(20));

}

}).start();

}

/**

*/

static void futureDemo() {

try {

/**

*/

Future<?> result = mExecutor.submit(new Runnable() {

@Override

public void run() {

fibc(20);

}

});

System.out.println("future result from runnable : " + result.get());

/**

*/

Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {

@Override

public Integer call() throws Exception {

return fibc(20);

}

});

System.out

.println("future result from callable : " + result2.get());

/**

*/

FutureTask<Integer> futureTask = new FutureTask<Integer>(

new Callable<Integer>() {

@Override

public Integer call() throws Exception {

return fibc(20);

}

});

// 提交futureTask

mExecutor.submit(futureTask) ;

System.out.println("future result from futureTask : "

+ futureTask.get());

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

}

/**

*/

static int fibc(int num) {

if (num == 0) {

return 0;

}

if (num == 1) {

return 1;

}

return fibc(num - 1) + fibc(num - 2);

}

}

输出结果

使用锁分段技术

线程是CPU调度的最小单元，同时线程是一种有限的系统资源，即线程不可能无限制地产生，并且线程的创建和销毁都有相应的开销。而进程一般指一个执行单元，在PC和移动设备上指一个程序或者一个应用。一个进程可以包含多个线程，因此进程和线程是包含与被包含的关系。

当线程池和workQueue都满了的情况下，对新加任务采取的处理策略也有几个默认的实现，分别如下

拒绝新任务进入，如果该线程池还没有被关闭，那么由调用线程处理该任务

| LinkedBlockingDueue | 双向链表实现的双向并发阻塞队列。同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作（插入/删除），并且该阻塞队列是支持线程安全的。 |

| ConcurrentLinkedQueue | 基于链接节点的无界线程安全队列 |

| PriorityBlockingQueue | 基于优先级的阻塞队列，依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序，Volley中的请求队列使用了优先级队列 |