java線程池的原理學習

Executor接口

若是查看jdk文檔，會發現java線程池都源自於這個超級接口Executor，可是這個接口自己比較簡單：

public interface Executor {

    /**
        在將來某個時間執行給定的命令。該命令可能在新的線程、已入池的線程或者正調用的線程中執行，
        這由 Executor 實現決定。
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution.
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

能夠看到Executor 中只有一個execute 方法。此接口提供一種將任務提交與每一個任務將如何運行的機制分離開來的方法，相比較爲每一個人物調用new Thread(Runnable r).start() ,咱們更偏向於使用Executor （執行器）來運行任務：

Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
 ...

實現一個執行器也很簡單：

class ThreadPerTaskExecutor implements Executor {
     public void execute(Runnable r) {
         new Thread(r).start();
     }
 }

ExecutorService接口

Executor 提供的方法太少了！根本不能知足平常所需，而從它派生下來的接口ExecutorService 則顯得更通用，畢竟它也是個Service。

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();    
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;   
    <T> Future<T> submit(Callable<T> task);   
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;  
    <T> T invokeAny(Collection<? extends Callable<T>> tasks) 
        throws InterruptedException, ExecutionException; 
     ...
}

能夠看到,ExecutorService 接口中包含了咱們日常使用的線程池的絕大多數方法，其中的一些方法在上文已經介紹過了。

AbstractExecutorService

AbstractExecutorService是一個抽象類，而且實現了ExecutorService接口。

public abstract class AbstractExecutorService implements ExecutorService

在這個類中，提供了ExecutorService 一些方法的默認實現，好比submit ，invokeAll ，首先看submit 的實現：

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
}

其中使用了newTaskFor 方法：

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
}

newTaskFor 方法只是簡單的將給定可調用任務包裝成一個RunnableFuture ，使其具備取消運行的特性。而submit 中直接將任務交給execute() 運行.
再來看invokeAll() :

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
        if (tasks == null)
            throw new NullPointerException();
        //建立一個list保存全部的結果
        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
        boolean done = false;
        try {
            for (Callable<T> t : tasks) {
                RunnableFuture<T> f = newTaskFor(t);
                futures.add(f);
                execute(f);   //運行任務
            }
            for (Future<T> f : futures) {
                if (!f.isDone()) {    //依次取結果
                    try {
                        f.get();     //這裏使用get是爲了等待運行完成，若是沒完成就會阻塞
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    }
                }
            }
            done = true;
            return futures;
        } finally {
            if (!done)   //若是發生異常，則取消全部任務
                for (Future<T> f : futures)
                    f.cancel(true);
        }
    }

續：java線程池的原理學習（二）