Java 多執行緒核心原理淺析：從線程創建到同步機制

前言：Java 多執行緒的革命性意義

Java 內建多執行緒支援是其區別於 C/C++ 早期版本的標誌性特性。將執行緒從作業系統層面抽象為語言級一等公民 (java.lang.Thread、Runnable、synchronized、wait/notify)，極大降低了併發程式開發門檻。本文從執行緒創建方式、生命週期狀態、同步機制、共享記憶體模型、常見陷阱五個維度，系統梳理 Java 多執行緒核心知識體系。

一、執行緒創建的兩種標準方式

1.1 繼承 Thread 類別

class MyThread extends Thread {
    @Override
    public void run() {
        // 執行緒執行主體
        System.out.println("Thread running: " + getName());
    }
}
// 使用
new MyThread().start(); // 必須呼叫 start()，而非 run()

缺點：Java 單繼承限制，已繼承其他類則無法使用；執行緒邏輯與執行緒控制耦合。

1.2 實作 Runnable 介面 (推薦)

class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Task running in: " + Thread.currentThread().getName());
    }
}
// 使用
Thread t = new Thread(new MyTask());
t.start();
// 或 Java 8+ Lambda
new Thread(() -> System.out.println("Lambda task")).start();

優點：邏輯與控制分離，可提交給執行緒池 (ExecutorService)、定時任務、CompletableFuture 等多種執行器複用。

1.3 實作 Callable + FutureTask (需返回結果/拋出異常)

Callable task = () -> { Thread.sleep(1000); return 42; };
FutureTask ft = new FutureTask<>(task);
new Thread(ft).start();
Integer result = ft.get(); // 阻塞獲取結果

二、執行緒生命週期與狀態轉換

Java 定義 6 種標準狀態 (Thread.State enum)：

NEW (新建) 
  │ start()
  ▼
RUNNABLE (可執行) ◄──────────────────┐
  │                                  │
  │ 获得 CPU 時間片                   │ 釋放 CPU / 等待資源
  ▼                                  │
RUNNING (運行中) ────────────────────┘
  │
  ├── sleep()/wait()/join() / I/O 阻塞 ──► BLOCKED / WAITING / TIMED_WAITING
  │           │
  │           │ 資源就緒 / 超時 / notify / interrupt
  │           ▼
  │       RUNNABLE
  │
  └── run() 結束 / 異常拋出 ──► TERMINATED (終止)

• BLOCKED：等待進入 synchronized 區塊/方法 (鎖被佔用)。
• WAITING：無限期等待 Object.wait()、Thread.join()、LockSupport.park()。
• TIMED_WAITING：定時等待 sleep()、wait(timeout)、join(timeout)、parkNanos()。

三、同步機制核心三件套

3.1 synchronized：內建監視器鎖

• 同步方法：public synchronized void method() 鎖 this (實例) 或 Class 物件 (靜態)。
• 同步區塊：synchronized(lockObj) { ... } 精確控制鎖範圍、鎖物件。
• 特性：可重入、互斥、可見性 (JMM happens-before)、編譯器/CPU 不會重排序進出同步區塊。

3.2 volatile：輕量級可見性保證

• 保證**讀寫可見性** (寫入對後續讀取可見)、**禁止指令重排序** (寫屏障/讀屏障)。
• 不保證原子性：volatile int i; i++; 非原子 (讀-改-寫三步驟)。
• 適用場景：狀態標誌 (volatile boolean shutdown)、雙重檢查鎖單例、獨立寫入讀取變數。

3.3 wait/notify：監視器等待/通知機制

• 前提：調用者必須持有物件鎖 (synchronized(obj) 內部)。
• obj.wait()：釋放鎖，進入等待集合。
• obj.notify()：喚醒一個等待執行緒 (隨機)。
• obj.notifyAll()：喚醒所有等待執行緒 (推薦，避免信號丟失)。
• 標準模式：

  
    // 等待方
    synchronized (lock) {
        while (conditionNotMet) lock.wait(); // while 防虛假喚醒
        // 執行邏輯
    }
    // 通知方
    synchronized (lock) {
        updateCondition();
        lock.notifyAll();
    }
    

四、Java 記憶體模型 (JMM) 核心

• 主記憶體：共享變數儲存區 (堆)。
• 工作記憶體：執行緒私有快取 (寄存器、L1/L2 Cache、編譯器優化)。
• 核心規則：volatile、synchronized、final、Thread.start/join、Lock.lock/unlock 建立 **happens-before** 關係，保證跨執行緒可見性與有序性。
• 指令重排序：編譯器/CPU 為效能重排指令，單執行緒語義不變，多執行緒下需同步手段約束。

五、高層同步工具 (java.util.concurrent) 速查

六、常見陷阱與避坑指南

1. 調用 run() 而非 start()：在主執行緒同步執行，無新執行緒。
2. 同步鎖物件不一致：synchronized(this) vs synchronized(lock) 混用導致保護失效。
3. volatile 當原子變數用：計數器、旗標複合操作需 AtomicInteger 或鎖。
4. wait/notify 遺漏 synchronized：拋 IllegalMonitorStateException。
5. 死鎖：多鎖獲取順序不一致。對策：固定全域獲取順序、tryLock(timeout)、避免巢狀鎖。
6. 活鎖/飢餓：過度禮讓、優先級反轉。對策：公平鎖、優先級繼承 (系統級)。
7. ThreadLocal 記憶體洩漏：執行緒池執行緒復用導致 ThreadLocalMap 殘留強引用。對策：remove() 清理、弱引用 Key 設計。

結語

Java 多執行緒從 Thread/Runnable 基礎創建，到 synchronized/volatile/wait/notify 核心同步三件套，再到 JMM 記憶體模型理論基石，最終沉澱為 java.util.concurrent 豐富高層工具箱。**理解底層原理 (監視器、happens-before、狀態轉換)，是為了在面對複雜併發場景時，能精準選擇工具、正確診斷死鎖/資料競爭/可見性問題、編寫高效且正確的併發代碼**。現代開發原則：優先使用不可變物件、無鎖資料結構、高層同步工具、執行緒池、CompletableFuture、Reactive Streams；謹慎使用低層 synchronized/volatile/wait/notify。

1. 上一篇文章： Java Swing 多執行緒實現等待提示對話框：避免 UI 凍結的最佳實踐
2. 下一篇文章： Java JNI 開發完整指南：調用本地 C/C++ 庫實現系統級功能

Java 程式設計入門

Java Swing 圖形化示範：選擇排序法對陣列排序完整程式

程式功能 建立一個 Swing 視窗應用程式，包含兩個文字區

Java 入門筆記（一）：JDK 下載、安裝與環境配置圖文教程

學習目標 掌握 JDK 官方下載流程 完成 JDK 安裝與

Spring MVC 整合 FreeMarker 完整配置指南 (XML + Java Config 雙版本)

環境資訊 框架：Spring MVC 3.2.x /

Java DOM 解析 XML 實戰：從入門到放棄（及更好的替代方案）

DOM 解析器：適合「小而全」的場景 DOM (Docume