Java中的Runable,Callable,Future,FutureTask,ExecutorService,Excetor,Excutors,ThreadPoolExcetor在这里对这些关键词，以及它们的用法做一个总结。

首先将它们分个类：

  • Runable,Callable
  • Future,FutureTask
  • ExecutorService,Executor,Excutors,ThreadPoolExcetor

对于Ranable和Callable

首先Java中创立线程的办法有三种：

  • 继承Thread类，笼罩run办法
  • 实现Runable接口，实现run办法
  • 实现Callable接口，实现run办法

三种实现的优缺点：

  • 继承Thread，单继承的缘故，不能再继承其余类，获取以后线程this
  • 实现Runable接口，没有返回值，获取以后线程Thread.currentThread()
  • 实现Callable接口，可通过Future.get()获取返回值，获取以后线程 Thread.currentThread()

继承Thread，两个步骤：

class DemoThread extends Thread {    @Override    public void run() {        super.run();        // Perform time-consuming operation...    }}//退出Java开发交换君样：756584822一起吹水聊天DemoThread t = new DemoThread();t.start();

继承Thread类，笼罩run()办法。
创立线程对象并用start()办法启动线程。
实现Runable，个别应用如下：

new Thread(new Runnable() {    @Override    public void run() {        // do something    }}).start();

为了简略。
以上两种形式获取线程执行的后果相当麻烦，不能间接获取。JDK1.5减少了 Callable, Callable 的 call() 办法能够返回值和抛出异样。Callable 能够返回装载有计算结果的 Future 对象。
Callable的源码：

public interface Callable<V> {    V call() throws Exception;}

Callable的根本应用办法：

FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {    @Override    public Integer call() throws Exception {        // do something        return null;    }});Thread thread = new Thread(futureTask);thread.start();Integer result = futureTask.get();

运行 Callable 工作能够拿到一个 Future 对象，通过Future的get()办法拿到线程执行的返回值。那么...Future，FutureTask区别是什么，怎么应用？
->next()

对于Future和FutureTask

为了获取线程的执行后果，引入了Future的FutureTask，那么他们是什么关系，如何应用？
Future类位于java.util.concurrent包下，它是一个接口：

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;}//退出Java开发交换君样：756584822一起吹水聊天

Future 定义了5个办法：

  • boolean cancel(boolean
    mayInterruptIfRunning)：试图勾销对此工作的执行。如果工作已实现、或已勾销，或者因为某些其余起因而无奈勾销，则此尝试将失败。当调用
    cancel() 时，如果调用胜利，而此工作尚未启动，则此工作将永不运行。如果工作曾经启动，则
    mayInterruptIfRunning 参数确定是否应该以试图进行工作的形式来中断执行此工作的线程。此办法返回后，对
    isDone() 的后续调用将始终返回 true。如果此办法返回 true，则对 isCancelled() 的后续调用将始终返回
    true。
  • boolean isCancelled()：如果在工作失常实现前将其勾销，则返回 true。
  • boolean isDone()：如果工作已实现，则返回 true。
    可能因为失常终止、异样或勾销而实现，在所有这些状况中，此办法都将返回 true。
  • V get()throws
    InterruptedException,ExecutionException：如有必要，期待计算实现，而后获取其后果。
  • V get(long timeout,TimeUnit unit) throws InterruptedException,
    ExecutionException, TimeoutException：
    如有必要，最多期待为使计算实现所给定的工夫之后，获取其后果（如果后果可用）。

总的来说Future提供了三种性能：

  • 判断工作是否实现； 可能中断工作；
  • 可能获取工作执行后果。

重点：
RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。
FutureTask的实现：

public class FutureTask<V> implements RunnableFuture<V>

RunnableFuture接口的实现：

public interface RunnableFuture<V> extends Runnable, Future<V> {    void run();}

FutureTask是Future接口的一个惟一实现类。
除了能够用Thread包装FutureTask外，还有另一种应用办法：

ExecutorService executor = Executors.newCachedThreadPool();FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {    @Override    public Integer call() throws Exception {        // do something        return null;    }//退出Java开发交换君样：756584822一起吹水聊天});executor.submit(futureTask);Integer result = futureTask.get();

这里用到了Executor 框架。
->next();

对于ExecutorService,Executor,Excutors,ThreadPoolExcetor

Executor框架在Java 5中被引入，Executor 框架是一个依据一组执行策略调用、调度、执行和管制的异步工作的框架。
在说Executor 框架之前咱们须要引入一个新的概念——线程池（ThreadPoolExecutor）：

public ThreadPoolExecutor(intcorePoolSize,        int maximumPoolSize,        long keepAliveTime,        TimeUnit unit,        BlockingQueue<Runnable> workQueue,        ThreadFactory threadFactory,        RejectedExecutionHandler handler)//退出Java开发交换君样：756584822一起吹水聊天

ThreadPoolExecutor是Executors类的底层实现。
在JDK帮忙文档中，有如此一段话：

“强烈建议程序员应用较为不便的 Executors 工厂办法 Executors.newCachedThreadPool()（无界限程池，能够进行自动线程回收）、Executors.newFixedThreadPool(int)（固定大小线程池）和 Executors.newSingleThreadExecutor()（单个后盾线程），它们均为大多数应用场景预约义了设置。”

那么ExecutorService,Excetor,Excutors都是什么？
Excetor是一个形象层面的外围接口：

public interface Executor {    void execute(Runnable command);}

ExecutorService 接口 对 Executor 接口进行了扩大，提供了返回 Future 对象，终止，敞开线程池等办法。

public interface ExecutorService extends Executor {    void shutdown();    //退出Java开发交换君样：756584822一起吹水聊天    <T> Future<T> submit(Callable<T> task);    <T> Future<T> submit(Runnable task, T result);    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;}

Executors 是一个工具类，相似于 Collections。提供工厂办法来创立不同类型的线程池，比方 FixedThreadPool 或 CachedThreadPool。

public class Executors {    public static ExecutorService newFixedThreadPool(int nThreads) {        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());        }             public static ExecutorService newCachedThreadPool() {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());        }}

以上是对Java多线程关键词的整顿，不至于一团乱麻。