手寫線程池的實現、創建、執行任務、銷毀

1.線程池實現的思維導圖，如果不理解JDK中線程池實現原理，看鏈接博客中末尾對線程池的原理的描述

https://www.cnblogs.com/jtfr/p/10187419.html

2.定義接口

package com.jtfr.core;

/**
 * 線程池必須實現的接口
 * @author 陳康明 qq：1123181523
 * @date 2019年3月10日
 */
public interface Executer {

    /**
     * 添加工作方法
     */
    void execute(Runnable runnable);
}

3.線程池實現類

package com.jtfr.core;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;


public class ThreadPool implements Executer {

    // 設置默認開啟線程個數 5 個
    private int workerNumber = 5;
    
    //線程工作組
    WorkerThread[] workThreads;
    
    //任務隊列 用個 list 后面添加方法用同步鎖定就行
    private List<Runnable> taskQueue = new LinkedList<Runnable>();
    
    
    public ThreadPool(int workerNumber){
        // 小於零 說明輸入錯誤，就不賦值，使用默認值。
        if (workerNumber > 0) {
            this.workerNumber = workerNumber;
        }
        // 開啟工作空間, 注意：要用成員變量
        workThreads = new WorkerThread[this.workerNumber];
        // 循環創建所有線程, 注意：要用成員變量
        for (int i = 0; i < this.workerNumber; i++) {
            // 創建的線程添加到 工作組 中
            workThreads[i] = new WorkerThread();
            // 創建的線程開啟, 並且命名 (創建了多個線程池名稱可能會沖突，后面再看了)
            new Thread(workThreads[i], "ThreadPool-worker " +(i+1)).start();
            System.out.println("初始化線程數" + (i + 1));
        }
    }
    
    /**
     * 添加任務方法，即把對象添加到 隊列中, 同時喚醒所有 wait中的線程
     */
    @Override
    public void execute(Runnable task) {
        synchronized (taskQueue) {
            taskQueue.add(task);
            taskQueue.notifyAll();
        }
    }
    
    /**
     * 銷毀線程池，默認是等待線程執行完了再銷毀
     */
    public void destory(){
        destory(true);
    }
    
    /**
     * 銷毀線程池，可以指定不執行隊列中剩下的任務，直接銷毀線程池了。
     * true表示繼續執行剩下的任務。
     */
    public void destory(boolean isRunTask){
        // 默認是等待線程執行完了再銷毀
        if (isRunTask) {
            //循環是否還存在任務，如果存在等待20毫秒處理時間
            while (!taskQueue.isEmpty()) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        //如果任務隊列已處理完成，銷毀線程，清空任務
        for (int i = 0; i < workerNumber; i++) {
            workThreads[i].setIsRunning();
            workThreads[i] = null;
            System.out.println("線程池銷毀了");
        }
        taskQueue.clear();
        // 不能設置 taskQueue==null 其他正在調用的地方可能報 null指針異常。
        //taskQueue = null;
    }
    
    /**
     * 內部類：做線程工作類
     */
    class WorkerThread implements Runnable{

        // 當前線程是否可用
        private Boolean isRunning = true;
        @Override
        public void run() {
            Runnable runnable = null;
            // 死循環，除非外界調用銷毀方法，設定 isRunning 為false
            while(isRunning){
                // 上面用的list 非線程安全，所以這里要同步去任務
                synchronized (taskQueue) {
                    // 如果線程活的，但是 taskQueue 是空，線程等待 20 毫秒
                    while(isRunning && taskQueue.isEmpty()){
                        try {
                            // wait會釋放鎖，其他工作線程可以繼續執行同步代碼塊里面內容。
                            taskQueue.wait(20);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 獲取任務，注意：要在同步代碼塊里面獲取任務。
                    // 為什么還要判斷 taskQueue 非空?
                    // 等待20毫秒，有任務能獲取到。
                    if (!taskQueue.isEmpty()) {
                        // list模擬隊列，所以獲取第一個元素。
                        runnable = taskQueue.remove(0);
                    }
                }
                // 注意：執行任務要在同步代碼塊外面，把鎖釋放出來給其他線程。
                // 判斷 runnable ，因為可能沒有獲取到任務。
                if (runnable != null) {
                    // 執行 run 方法，要任務實現Runnable接口，實際上是為了保證有 run 方法，和線程沒關系。
                    runnable.run();
                }
                // 結束后置 null 方便回收。
                runnable = null;
            }
        }
        /**
         * 銷毀線程，實際上就是不再死循環，正常結束了工作線程。
         */
        public void setIsRunning(){
            this.isRunning = false;
        }
        
    }

}

4.測試類

package com.jtfr.test;

import com.jtfr.core.ThreadPool;

public class TestMain {

    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(-5);
        for (int i = 0; i < 100; i++) {
            threadPool.execute(new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }));
        }
        // 調用銷毀方法，不執行剩下的任務
        threadPool.destory(false);
    }
}

5.擴展

https://www.cnblogs.com/jtfr/p/10507437.html

package com.jtfr.test;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * 測試 wait和sleep方法
 * 按照網上說的：wait會釋放鎖，sleep不會釋放鎖，寫個案例執行下。
 * @author 陳康明 qq：1123181523
 * @date 2019年3月10日
 */
public class TestWait {
    
    private static List<String> list = new ArrayList<String>();

    public static void main(String[] args) {
        TestWait test = new TestWait();
        WaitSleep w1 = test.new WaitSleep();
        WaitSleep w2 = test.new WaitSleep();
        WaitSleep w3 = test.new WaitSleep();
        w1.start();
        w2.start();
        w3.start();
    }
    
    class WaitSleep extends Thread{
        
        @Override
        public void run() {
            synchronized (list) {
                try {
                    System.out.println(Thread.currentThread().getName()+"當前系統時間："+new SimpleDateFormat("hh:mm:ss").format(new Date()));
                    // 等待 10 秒， 看其他對象是否拿到鎖
                    list.wait(10000);
                    //Thread.sleep(10000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

源碼

https://files.cnblogs.com/files/jtfr/JtfrThreadPool.rar