之前使用用過執行緒池，但是就是看看文件介面複製貼上過來用用而已，沒有認真學習過，最近比較好奇執行緒池想學習一下，所以在此做個筆記。

JDK併發包中的執行緒池有：

 ExecutorService single = Executors.newSingleThreadExecutor();

 ExecutorService fixed = Executors.newFixedThreadPool(5);

 ExecutorService cached = Executors.newCachedThreadPool();

 ExecutorService scheduled = Executors.newScheduledThreadPool(5);
 

分別是：建立一個只有一個執行緒的執行緒池執行任務，沒有得到執行的任務儲存到佇列中。

  建立一個固定大小的執行緒池，上面建立了5個執行緒的執行緒池。

建立一個快取執行緒池，只要有任務沒有執行緒處理就會建立執行緒處理，當有大量閒置執行緒時候根據策略銷燬一些執行緒（策略此處不展開，以後描述）。

建立一個支援排程，定時的執行緒池，指定5個執行緒，支援增加執行緒。

接下來看一下JDK執行緒池的繼承結構：

其中Executor是一個執行器，只有一個execute方法，原始碼如下：

package java.util.concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;

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

ExecutorService是一個執行服務，只要包含的是任務的提交，執行緒池關閉等操作，JDK原始碼如下：

package java.util.concurrent;

import java.util.List;
import java.util.Collection;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;

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> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
			throws InterruptedException;

	<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;

	<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
			throws InterruptedException, ExecutionException, TimeoutException;
}
 

AbstractExecutorService抽象類是對ExecutorService的部分方法實現，原始碼就不貼上了。

ScheduledExecutorService介面繼承了ExecutorService介面的一些方法宣告，之後又添加了一些自己的排程，定時方法等特性。

ScheduledThreadPoolExecutor便是對ScheduledExecutorService的實現，同時繼承至ThreadPoolExecutor，來支援一些非定時任務的執行特性。

這就是執行緒池的巨集觀繼承結構。

接下來看一些具體實現，下面是簡單入門的一個示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolStudy {

	public static void main(String[] args) {

		ExecutorService scheduled = Executors.newSingleThreadExecutor();

		single.submit(new RunnableDemo());
		
		single.shutdown();

	}

}

class RunnableDemo implements Runnable {

	@Override
	public void run() {
		System.out.println("run ...");
	}

}

建立一個了一個單個執行緒的執行緒池，然後提交任務執行完畢之後關閉執行緒池。

第一步建立單個執行緒的執行緒池時候呼叫的是Executors的newSingleThreadExecutor方法。

newSingleThreadExecutor方法原始碼如下：

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

發現內部建立了一個FinalizableDelegatedExecutorService物件，檢視FinalizableDelegatedExecutorService聲明發現：FinalizableDelegatedExecutorService繼承於DelegatedExecutorService類。原始碼如下（java.util.concurrent.Executors.FinalizableDelegatedExecutorService）：

    static class FinalizableDelegatedExecutorService//  是Executors的一個內部類
        extends DelegatedExecutorService {
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }
        protected void finalize() {
            super.shutdown();
        }
    }

檢視原始碼便知道FinalizableDelegatedExecutorService作用主要是在垃圾回收時候銷燬執行緒。

在檢視其父類原始碼，也是Executors的一個內部類，實現如下：

 static class DelegatedExecutorService extends AbstractExecutorService {
        private final ExecutorService e;
        DelegatedExecutorService(ExecutorService executor) { e = executor; }
        public void execute(Runnable command) { e.execute(command); }
        public void shutdown() { e.shutdown(); }
        public List<Runnable> shutdownNow() { return e.shutdownNow(); }
        public boolean isShutdown() { return e.isShutdown(); }
        public boolean isTerminated() { return e.isTerminated(); }
        public boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.awaitTermination(timeout, unit);
        }
        public Future<?> submit(Runnable task) {
            return e.submit(task);
        }
        public <T> Future<T> submit(Callable<T> task) {
            return e.submit(task);
        }
        public <T> Future<T> submit(Runnable task, T result) {
            return e.submit(task, result);
        }
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException {
            return e.invokeAll(tasks);
        }
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                             long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.invokeAll(tasks, timeout, unit);
        }
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
            throws InterruptedException, ExecutionException {
            return e.invokeAny(tasks);
        }
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                               long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            return e.invokeAny(tasks, timeout, unit);
        }
    }

重點：由於Single執行緒池的功能比較簡單， 返回代理物件目的是遮蔽掉掉newSingle***不需要的方法

由註釋可以知道DelegatedExecutorService類職責是：一個包裝類，用來僅暴露ExecutorService實現類中的ExecutorService的方法，本例項中不適用代理的話正常應該返回一個ThreadPoolExecutor物件，但是由於不想暴露ThreadPoolExecutor的所有方法，所以返回代理物件。

同理：DelegatedScheduledExecutorService是ScheduledThreadPoolExecutor的一個代理類，不想暴露ScheduledExecutorService的所有方法。

		// FinalizableDelegatedExecutorService
		System.out.println(Executors.newSingleThreadExecutor());


		// DelegatedScheduledExecutorService
		System.out.println(Executors.newSingleThreadScheduledExecutor());

以上都是返回代理物件！

拓展，代理的實現：把被代理物件放到代理物件中，作為一個私有成員變數，然後對被代理的物件的部分想暴露出來的方法在代理物件中實現即可！

備註：ThreadPoolExecutor是一個子類 ，它使用執行緒池中執行緒執行提交的任務，ScheduledThreadPoolExecutor也是一個子類 ，它使用執行緒池中執行緒執行提交的任務。

進行小總結：FinalizableDelegatedExecutorService物件就是對代理物件DelegatedExecutorService又包了一層確保垃圾回收銷燬執行緒。

但是FinalizableDelegatedExecutorService卻沒有對DelegatedScheduledExecutorService物件進行包層。具體什麼原因呢？

對於非newSingle***的建立，返回的是對應的Executor：

	       // FinalizableDelegatedExecutorService
		System.out.println(Executors.newSingleThreadExecutor());

		// DelegatedScheduledExecutorService
		System.out.println(Executors.newSingleThreadScheduledExecutor());
		
		// ThreadPoolExecutor
		System.out.println(Executors.newFixedThreadPool(5));

		// ScheduledThreadPoolExecutor
		System.out.println(Executors.newScheduledThreadPool(5));
		
		// ThreadPoolExecutor
		System.out.println(Executors.newCachedThreadPool());