線程池工作原理

原文位址：https://www.cnblogs.com/wxwall/p/7050698.html

前段時間自己研究了下線程池的實作原理，通過一些源碼對比，發現其實核心的東西不難，于是抽絲剝繭，決定自己實作一個簡單線程池，當自已實作了出一個線程池後。發現原來那麼高大上的東西也可以這麼簡單。

先上原理圖：為了更好的在手機上顯示，我重新把圖畫了一遍

上代碼之前，要先補充一下線程池構造的核心幾個點

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的實作比這強大的多，而且還具備當工作線程處理不過來時，可以産生新的線程來處理任務，這個數量不能超過原先定義的最大線程數，而在本例中都沒實作這些功能。

我相信當想了解一個子產品的功能時，如果一開始就了解其中最核心的點，然後向外慢慢擴充，那麼學習這個子產品時一定能省下不少時間，而且了解将很深刻。希望這個簡單線程池實作能讓你有所領悟，以更加簡單的方式了解線程池，了解了線程池，對于其他池化技術，原理都是相通的。

最後我想說：我相信寫好一篇文章能讓大家了解不困難都是用了心的，您也點個贊支援支援。