Java 線程池簡單實現：從原理到代碼的完整實戰

為什麼需要線程池？

建立/銷毀線程開銷大（T1、T3），頻繁創建導致效能低落。線程池將創建/銷毀移至啟動/關閉或閒置時段，並固定線程數量，大幅降低併發請求下的資源消耗。

核心組件

• ThreadPoolManager：單例管理器，負責建立/銷毀池、任務入隊。
• WorkThread：工作線程，循環從隊列取任務執行。
• Task (Upload)：任務介面/抽象類，定義 `uploadPic()` 執行邏輯。
• 任務隊列：`Collections.synchronizedList(new LinkedList())` 實現緩衝與同步。

關鍵代碼實現

線程池管理器

public class ThreadPoolManager {
    private static ThreadPoolManager instance;
    private final List<Upload> taskQueue = Collections.synchronizedList(new LinkedList<>());
    private final WorkThread[] workQueue;
    private static int worker_num = 5;

    private ThreadPoolManager() { this(5); }
    private ThreadPoolManager(int num) {
        worker_num = num;
        workQueue = new WorkThread[worker_num];
        for (int i = 0; i < worker_num; i++) workQueue[i] = new WorkThread(i);
    }

    public static synchronized ThreadPoolManager getInstance() {
        if (instance == null) instance = new ThreadPoolManager();
        return instance;
    }

    public void addTask(Upload task) {
        synchronized (taskQueue) {
            if (task != null) {
                taskQueue.add(task);
                taskQueue.notifyAll();
            }
        }
    }

    public void destory() {
        for (WorkThread wt : workQueue) wt.stopThread();
        synchronized (taskQueue) { taskQueue.clear(); }
    }

    private class WorkThread extends Thread {
        private final int taskId;
        private volatile boolean isRuning = true, isWaiting = false;

        WorkThread(int id) { this.taskId = id; start(); }

        public void stopThread() { isRuning = false; }

        @Override public void run() {
            while (isRuning) {
                Upload temp = null;
                synchronized (taskQueue) {
                    while (isRuning && taskQueue.isEmpty()) {
                        try { taskQueue.wait(20); } catch (InterruptedException ignored) {}
                    }
                    if (isRuning) temp = taskQueue.remove(0);
                }
                if (temp != null) {
                    isWaiting = false;
                    temp.uploadPic();
                    isWaiting = true;
                }
            }
        }
    }
}

任務介面與實作

public abstract class Upload {
    protected String info;
    public abstract boolean uploadPic();
    public String getInfo() { return info; }
}

public class TaskUpload extends Upload {
    public TaskUpload(String info) { this.info = info; }
    @Override public boolean uploadPic() {
        System.out.println(info + " sleep begin...");
        try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(info + " sleep end...");
        return false;
    }
}

測試啟動

public class ThreadPoolManagerTest {
    public static void main(String[] args) {
        Upload[] tasks = new TaskUpload[7];
        for (int i = 0; i < 7; i++) tasks[i] = new TaskUpload("task id is " + i);
        ThreadPoolManager pool = ThreadPoolManager.getInstance();
        pool.BatchAddTask(tasks);
        pool.destory();
    }
}

適用場景與注意事項

• 適用：大量短任務（Web 請求）、高效能要求、突發流量。
• 不適用：長連線任務（Telnet/SSH），線程創建開銷可忽略。
• 注意：任務隊列無界可能導致 OOM，生產環境建議使用 `ThreadPoolExecutor` 內建有界隊列與拒絕策略。