您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> Java 相關知識

Java 線程同步鎖選擇指南：避開 String 常量池陷阱，採用零長度 byte 陣列最佳實踐

編輯：Java 相關知識

前言：一個經典的同步鎖失效案例

在 Java 多執行緒開發中，synchronized 關鍵字是最基礎的同步手段。但許多開發者在選擇鎖物件時掉入陷阱，導致本應獨立的鎖變成全局共享鎖，嚴重影響併發效能甚至產生邏輯錯誤。本文通過一個反面教材，深度剖析鎖物件選擇的核心原則，並給出業界公認的最佳實踐方案。

一、反面教材：String 常量池導致的「意外全局鎖」

錯誤代碼

public class SyncTest {
    private String name = "name";  // 字面量進入常量池
    
    public void method(String flag) {
        synchronized (name) {  // 危險！鎖定的是常量池中共享的 "name" 物件
            System.out.println(flag + ", invoke method ....");
            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
        }
    }
    
    public static void main(String[] args) {
        SyncTest test1 = new SyncTest();
        SyncTest test2 = new SyncTest();  // 兩個不同實例
        
        // 預期：test1 的兩線程同步、test2 的兩線程同步、test1/test2 互不干擾
        // 實際：四線程全串行，因為鎖住的是同一個常量池 "name" 物件
    }
}

問題根因

Java 編譯器將字面量 "name" 放入字串常量池（String Constant Pool）。
JVM 保證常量池中同一字面量只有一個物件實例（String.intern() 機制）。
test1.name 與 test2.name 指向同一個 String 物件。
synchronized(name) 實際鎖定的是這個共享物件，導致所有實例共用同一把鎖。

後果：原本應該獨立的實例級同步變成了全局串行，併發效能暴跌，業務邏輯可能錯誤。

二、同類陷阱：其他「看似私有實則共享」的物件

物件類型	風險原因	示例
`String` 字面量 / `intern()`	常量池全局唯一	`synchronized("lock")`
包裝類型常量（`Integer` -128~127、`Boolean`、`Byte`、`Short`、`Character` 0~127）	JVM 快取池全局唯一	`synchronized(Integer.valueOf(100))`
`Class` 物件	每個類僅一個 `Class` 實例	`synchronized(MyClass.class)`（若非有意做類級鎖）
不可變物件被多處引用	如共享的配置物件、單例物件	`synchronized(sharedConfig)`

三、正確選擇：三大推薦鎖物件模式

1. 實例級鎖：私有 final Object / 零長度 byte 陣列（推薦）

public class SyncTest {
    // 方案 A：私有 final Object（語義清晰，佔用 16 bytes 對象頭）
    private final Object lock = new Object();
    
    // 方案 B：零長度 byte 陣列（推薦，佔用 16 bytes 對象頭 + 0 bytes 數據，無數組複製開銷）
    private final byte[] lock = new byte[0];
    
    public void method() {
        synchronized (lock) {  // 每個實例擁有獨立鎖物件
            // 臨界區代碼
        }
    }
}

為什麼推薦 new byte[0]？

記憶體極小：僅對象頭（12-16 bytes），無額外數據區。
語義純粹：明確表達「僅作為鎖使用」，不會被誤用於業務邏輯。
避免逃逸分析優化失效：相比 new Object()，陣列物件在某些 JIT 編譯器中更易被標記為非逃逸，鎖消除優化機會更大。
不可變長度：無法被 Arrays.copyOf 等操作修改結構，天然安全。

2. 類級鎖：`static final Object` / `Class` 物件（有意為之）

public class Singleton {
    private static final Object CLASS_LOCK = new Object();  // 或直接用 MyClass.class
    
    public static void staticMethod() {
        synchronized (CLASS_LOCK) {  // 所有實例、所有線程共享此鎖
            // 靜態資源保護
        }
    }
}

3. 方法級鎖：`synchronized` 修飾實例/靜態方法（簡單場景）

// 實例方法鎖：鎖住 this
public synchronized void instanceMethod() { ... }

// 靜態方法鎖：鎖住 Class 物件
public static synchronized void staticMethod() { ... }

注意：方法級鎖粒度較粗，整個方法體為臨界區，高併發下建議縮小同步塊範圍。

四、進階：鎖粒度與效能優化

1. 縮小同步塊範圍

// 差：整個方法同步，包含耗時 I/O、睡眠
public synchronized void badMethod() {
    doQuickWork();
    Thread.sleep(1000);  // 鎖持有期間阻塞其他線程
    doMoreWork();
}

// 好：僅保護共享狀態讀寫
public void goodMethod() {
    doQuickWork();
    synchronized (lock) {
        updateSharedState();  // 僅共享狀態操作加鎖
    }
    Thread.sleep(1000);  // 釋放鎖後睡眠
    doMoreWork();
}

2. 避免死鎖：固定獲取順序

// 線程 1：synchronized(lockA) -> synchronized(lockB)
// 線程 2：synchronized(lockB) -> synchronized(lockA)  // 死鎖風險

// 解決：全局統一獲取順序（如按 hashCode 或 id 排序）
public void transfer(Account from, Account to, int amount) {
    Object firstLock = from.hashCode() < to.hashCode() ? from : to;
    Object secondLock = firstLock == from ? to : from;
    synchronized (firstLock) {
        synchronized (secondLock) {
            // 安全轉賬
        }
    }
}