原理圖

上程式碼之前，要先補充一下執行緒池構造的核心幾個點

1. 執行緒池裡的核心執行緒數與最大執行緒數
2. 執行緒池裡真正工作的執行緒worker
3. 執行緒池裡用來存取任務的佇列BlockingQueue
4. 執行緒中的任務task

本例實現簡化了一些，只實現了BlockingQueue存放任務，然後每個worker取任務並執行，下面看程式碼

首先定義一個執行緒池ThreadExcutor

class ThreadExcutor{

    //建立
    private volatile boolean RUNNING = true;

    //所有任務都放佇列中，讓工作執行緒來消費
    private
 
 static BlockingQueue<Runnable> queue = null;

    private final HashSet<Worker> workers = new HashSet<Worker>();

    private final List<Thread> threadList = new ArrayList<Thread>();

    //工作執行緒數
    int poolSize = 0;
    //核心執行緒數（建立了多少個工作執行緒）
    int coreSize = 0;

    boolean
 
 shutdown = false;

    public ThreadExcutor(int poolSize){
        this.poolSize = poolSize;
        queue = new LinkedBlockingQueue<Runnable>(poolSize);
    }

    public void exec(Runnable runnable) {
        if (runnable == null) throw new NullPointerException();
        if(coreSize < poolSize){
            addThread(runnable);
        }
 
else{
            //System.out.println("offer" +  runnable.toString() + "   " + queue.size());
            try {
                queue.put(runnable);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void addThread(Runnable runnable){
        coreSize ++;
        Worker worker = new Worker(runnable);
        workers.add(worker);
        Thread t = new Thread(worker);
        threadList.add(t);
        try {
            t.start();
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public void shutdown() {
        RUNNING = false;
        if(!workers.isEmpty()){
            for (Worker worker : workers){
                worker.interruptIfIdle();
            }
        }
        shutdown = true;
        Thread.currentThread().interrupt();
    }
   //這裡留個位置放內部類Worker
 }

然後定義一個工作執行緒物件Worker

這個內部類Worker是用來執行每個任務的，在建立執行緒池後，往執行緒裡新增任務，每個任務都是由Worker一個一個來啟動的。

/**
     * 工作執行緒
     */
    class  Worker implements Runnable{

        public Worker(Runnable runnable){
            queue.offer(runnable);
        }

        @Override
        public void run() {
            while (true && RUNNING){
                if(shutdown == true){
                    Thread.interrupted();
                }
                Runnable task = null;
                try {
                    task = getTask();
                    task.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public Runnable getTask() throws InterruptedException {
            return queue.take();
        }

        public void interruptIfIdle() {
            for (Thread thread :threadList) {
                System.out.println(thread.getName() + " interrupt");
                thread.interrupt();
            }
        }
    }

首先注意的一點，這個Worker是個內部類，是線上程池內宣告的。

exec方法

Worker怎麼工作

這個工作執行緒例項化的時候就先加入一個任務到佇列中，也就是說在例項化這個工作執行緒時，這個工作執行緒也是一個任務被加入到執行緒池中。然後就是run方法，這個run方法是執行緒調start方法生成的執行緒，而Worker調的run方法並沒有生成新的執行緒。就是一個迴圈，一直在不停的從佇列中取任務，然後執行。可以看到，取佇列的方法是take()，這個方法意思如果佇列為空了，取不到資料時就阻塞佇列。

然後看shutdown()

你每天辛勤的勞動著，突然接收到上面的命令，說活暫時不要接了，先停下來，當你還沒搞清楚狀況時，接著你的領導又把你開除了，說公司要倒了，你先下崗吧，一會我也得下崗了。這就是shutdown做的事，shutdown必須是主執行緒才能停止工作執行緒。
shutdown方法並不是用執行緒那種強制停止的搞法，而是先用一個識別符號告訴工作執行緒，不要再接任務了。然後通知工作執行緒，你可以interrupt()了，當所有的執行緒停止後記得要把主執行緒也停掉，這樣，一個簡單任務的執行緒池就完成了。

讓我們來測試一下：

/**
 * Created by wxwall on 2017/6/7.
 */
public class TheadBlockedQ {
    public static void main(String[] args) throws InterruptedException {
        ThreadExcutor excutor = new ThreadExcutor(3);
        for (int i = 0; i < 10; i++) {
            excutor.exec(new Runnable() {
                @Override
                public void run() {
                    System.out.println("執行緒 " + Thread.currentThread().getName() + " 在幫我幹活");
                }
            });
        }
       excutor.shutdown();
    }
}

輸出結果為：

執行緒 Thread-0 在幫我幹活
執行緒 Thread-2 在幫我幹活
執行緒 Thread-1 在幫我幹活
執行緒 Thread-0 在幫我幹活
執行緒 Thread-2 在幫我幹活
執行緒 Thread-2 在幫我幹活
執行緒 Thread-1 在幫我幹活
執行緒 Thread-0 在幫我幹活
Thread-0 interrupt
Thread-1 interrupt
Thread-2 interrupt
Thread-0 interrupt
Thread-1 interrupt
Thread-2 interrupt
Thread-0 interrupt
Thread-1 interrupt
Thread-2 interrupt

這當然是最簡單實現，JDK的實現比這強大的多，而且還具備當工作執行緒處理不過來時，可以產生新的執行緒來處理任務，這個數量不能超過原先定義的最大執行緒數，而在本例中都沒實現這些功能。
我相信當想了解一個模組的功能時，如果一開始就瞭解其中最核心的點，然後向外慢慢擴充套件，那麼學習這個模組時一定能省下不少時間，而且理解將很深刻。希望這個簡單執行緒池實現能讓你有所領悟，以更加簡單的方式瞭解執行緒池，瞭解了執行緒池，對於其他池化技術，原理都是相通的。

轉載出處：https://www.cnblogs.com/wxwall/p/7050698.html