Java 多線程核心技術全景：創建方式、同步機制、線程通信、鎖優化與並發包升級

線程與進程本質區別

四種線程創建方式對比

Runnable 共享實例線程安全示範

class CounterTask implements Runnable {
    private int count = 100;
    
    @Override public void run() {
        while (true) {
            synchronized (this) { // 共享實例 this 為鎖
                if (count <= 0) break;
                try { Thread.sleep(100); } catch (InterruptedException ignored) {}
                System.out.println(Thread.currentThread().getName() + " 剩餘: " + count--);
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        CounterTask task = new CounterTask(); // 單一實例
        new Thread(task, "線程-A").start();
        new Thread(task, "線程-B").start();
        new Thread(task, "線程-C").start();
    }
}

關鍵：synchronized(this) 確保三線程互斥訪問共享 count，輸出 100→0 無重複無遺漏。

synchronized 鎖對象規則

wait/notify 精確線程通信

核心規則

1. 必須在同步塊內：持有鎖才能調用
2. 鎖對象調用：lock.wait()、lock.notify()
3. wait 釋放鎖：進入等待集，被 notify 後重新競爭鎖
4. notify 隨機喚醒一個，notifyAll 喚醒全部

經典生產者-消費者模式

class SharedBuffer {
    private final List buffer = new ArrayList<>();
    private final int capacity = 10;
    
    public synchronized void produce(int value) throws InterruptedException {
        while (buffer.size() == capacity) wait(); // 滿等待
        buffer.add(value);
        notifyAll(); // 喚醒消費者
    }
    
    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) wait(); // 空等待
        int value = buffer.remove(0);
        notifyAll(); // 喚醒生產者
        return value;
    }
}

為什麼定義在 Object 而非 Thread？

鎖屬於任意對象，一個程式可有多把鎖。線程需在持有特定鎖的同步塊內調用該鎖的 wait/notify，故定義在 Object 通用。

線程生命週期與狀態轉換

NEW → (start) → RUNNABLE ↔ (時間片/鎖/IO) → BLOCKED/WAITING/TIMED_WAITING → (結束) → TERMINATED

安全停止線程：中斷模式

已棄用：stop() (破壞鎖一致性)、suspend()/resume() (易死鎖)

標準協作式停止

class Worker implements Runnable {
    private volatile boolean running = true;
    
    public void run() {
        while (running && !Thread.currentThread().isInterrupted()) {
            try {
                // 業務邏輯
                TimeUnit.MILLISECONDS.sleep(200); // 可中斷阻塞
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重設標誌
                break;
            }
        }
        // 清理資源
    }
    
    public void shutdown() { running = false; }
}

中斷方法對比

單例模式線程安全演進

懶漢式：雙重檢查鎖 (DCL) 最終版

public class Singleton {
    private static volatile Singleton instance; // volatile 禁止指令重排
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {                  // 第一次檢查：無鎖快速路徑
            synchronized (Singleton.class) {     // 類級鎖
                if (instance == null) {          // 第二次檢查：防重複創建
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

JDK 1.5+ 並發包升級：Lock 與 Condition

ReentrantLock 核心優勢

• 可中斷獲取：lock.lockInterruptibly()
• 非阻塞嘗試：lock.tryLock()、tryLock(timeout)
• 公平鎖選項：new ReentrantLock(true)
• 多條件變量：lock.newCondition() 精確喚醒

Condition 替代 wait/notify

class BoundedBuffer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Object[] items = new Object[10];
    private int putPtr, takePtr, count;
    
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) notFull.await(); // 精確等待
            items[putPtr] = x;
            if (++putPtr == items.length) putPtr = 0;
            ++count;
            notEmpty.signal(); // 只喚醒消費者
        } finally { lock.unlock(); }
    }
    
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) notEmpty.await();
            Object x = items[takePtr];
            if (++takePtr == items.length) takePtr = 0;
            --count;
            notFull.signal(); // 只喚醒生產者
            return x;
        } finally { lock.unlock(); }
    }
}

對比優勢：notifyAll 驚群效應 vs signal 精確喚醒；多條件變量語義清晰；支援 awaitUninterruptibly、awaitUntil 等進階等待。

常用並發工具類速查