java多线程开发，Executors、FutureTask、Callable

   java多线程如何应用呢，几乎学java的同学都知道Thread类和Runable接口。继承Thread类或者实现Runable接口，调用thread的start方法即可启动线程。

   然后是线程池，就是启动一系列的线程，当需要启动某个线程时，从线程池中拿取一个线程。

   最近使用到需要启动一个线程进行复杂运算并且得到其返回值。

　就用到Callable。

 

  

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;
}

Callable 接口是从jdk1.5之后才有的，其使用call方法代替run方法，相较Runable：可以有返回值，也可以抛出异常，这两点是引入Callable的主要原因

Callable应该如何用才会有返回值呢:先有个例子 在来一一讲解;

    ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyTask());
        String result = null;
        try {
            result= (String) future.get(3, TimeUnit.MINUTES);  
        } catch (TimeoutException e) {
            log.error("TimeoutException!");
        } catch (InterruptedException e) {
            log.error("InterruptedException:" + e.getMessage());
        } catch (ExecutionException e) {
            log.error("ExecutionException:" + e.getMessage());
        }

(一).Executors的用法

　　Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1. newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

3. newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

我们使用了newSingleThreadExecutor 来创建一个单线程的线程池，翻一下源码看里面做了什么事

 public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

ok，创建了一个代理线程池来处理单线程的问题，其中扔进去一个只有一个线程并且最大值为1的线程池。

代理线程池先不用说，其实里面调用的也是完全的ThreadPoolExeutor的方法，先来解析一下ThreadPoolExeutor的参数：

ThreadPoolExecutor的完整构造方法的签名是：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) .

corePoolSize - 池中所保存的线程数，包括空闲线程。

maximumPoolSize-池中允许的最大线程数。

keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

unit - keepAliveTime 参数的时间单位。

workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。

threadFactory - 执行程序创建新线程时使用的工厂。

handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

ThreadPoolExecutor是Executors类的底层实现。

 

(二).executor.submit

   既然用到了submit方法，就看一看submit里面做了什么事情：

 public <T> Future<T> submit(Callable<T> task) {
            return e.submit(task);
        }
//这个是DelegatedExecutorService 的方法，这个类是FinalizableDelegatedExecutorService的父类，
//看到他其实是调用ThreadPoolExecutor的submit方法，其参数为Callable类型。T为返回值类型

  public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
   protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }
//这是AbstractExecutorService类中的方法，其是ThreadPoolExecutor的父类，同时实现了ExecutorService接口

于是乎，FutureTask实现了Runable接口，所以实现Callable的过程其实就是启动了一个Runable来执行Callable，以方便更好的控制。

void innerRun() {
            if (!compareAndSetState(0, RUNNING))
                return;
            try {
                runner = Thread.currentThread();
                if (getState() == RUNNING) // recheck after setting thread
                    innerSet(callable.call());
                else
                    releaseShared(0); // cancel
            } catch (Throwable ex) {
                innerSetException(ex);
            }
        }
//这个是FutureTask中的run()的实现，在这里它讲call()方法的返回值赋值给了result，并且吃掉了异常，至于为什么我们后面说

FutureTask是实现了Future接口的，Future接口主要有这几种方法来控制其Callable任务：
    A、boolean cancel(Boolean mayInterruptlfRunning):试图取消该Future里关联的Callable任务
    B、V get()：返回Callable任务里的call方法的返回值，调用该方法将导致线程阻塞，必须等到子线程结束才得到返回值
    C、V get(long timeout, TimeUnit unit)：返回Callable任务里的call方法的返回值，该方法让程序最多阻塞timeout和unit指定的时间。
        如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException。
    D、boolean isCancelled：如果在Callable任务正常完成前被取消，则返回true。
    E、boolean isDone：如果Callable任务已经完成，则返回true

其主要是get()方法，即获取线程的返回值的方法。这个是阻塞的，即当调用get的时候会等待线程结束才能有返回，否则就一直等待，或者等待超过超时时间。

还记得run的时候吃掉了异常么，那里吃掉的异常将会在这里抛出来：所以，如果不调用get()方法，则执行的call方法是不抛出异常的，也没有返回值，即跟普通的Runable一样的。

 

//这个是get的主要实现方法  
V innerGet(long nanosTimeout) throws InterruptedException, ExecutionException, TimeoutException {
            if (!tryAcquireSharedNanos(0, nanosTimeout))
                throw new TimeoutException();
            if (getState() == CANCELLED)
                throw new CancellationException();
            if (exception != null)
                throw new ExecutionException(exception);
            return result;
        }

 

(三):ExecutorService还提供了一些其他的方法，如中断线程。。

 

(四):摘抄一些

下面介绍一下几个类的源码：

ExecutorService  newFixedThreadPool (int nThreads):固定大小线程池。

可以看到，corePoolSize和maximumPoolSize的大小是一样的（实际上，后面会介绍，如果使用无界queue的话maximumPoolSize参数是没有意义的），keepAliveTime和unit的设值表名什么？-就是该实现不想keep alive！最后的BlockingQueue选择了LinkedBlockingQueue，该queue有一个特点，他是无界的。

1.     public static ExecutorService newFixedThreadPool(int nThreads) {    2.             return new ThreadPoolExecutor(nThreads, nThreads,    3.                                           0L, TimeUnit.MILLISECONDS,    4.                                           new LinkedBlockingQueue<Runnable>());    5.         }

ExecutorService  newSingleThreadExecutor()：单线程

1.     public static ExecutorService newSingleThreadExecutor() {    2.             return new FinalizableDelegatedExecutorService    3.                 (new ThreadPoolExecutor(1, 1,    4.                                         0L, TimeUnit.MILLISECONDS,    5.                                         new LinkedBlockingQueue<Runnable>()));    6.         }

ExecutorService newCachedThreadPool()：无界线程池，可以进行自动线程回收

这个实现就有意思了。首先是无界的线程池，所以我们可以发现maximumPoolSize为big big。其次BlockingQueue的选择上使用SynchronousQueue。可能对于该BlockingQueue有些陌生，简单说：该QUEUE中，每个插入操作必须等待另一个线程的对应移除操作。

1.     public static ExecutorService newCachedThreadPool() {    2.             return new ThreadPoolExecutor(0, Integer.MAX_VALUE,    3.                                           60L, TimeUnit.SECONDS,    4.                                           new SynchronousQueue<Runnable>());        }

先从BlockingQueue<Runnable> workQueue这个入参开始说起。在JDK中，其实已经说得很清楚了，一共有三种类型的queue。

所有BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：

如果运行的线程少于 corePoolSize，则 Executor始终首选添加新的线程，而不进行排队。（如果当前运行的线程小于corePoolSize，则任务根本不会存放，添加到queue中，而是直接抄家伙（thread）开始运行）

如果运行的线程等于或多于 corePoolSize，则 Executor始终首选将请求加入队列，而不添加新的线程。

如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。

queue上的三种类型。

 

排队有三种通用策略：

直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

有界队列。当使用有限的 maximumPoolSizes时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量