Java 多線程同步深度解析：synchronized 方法、同步塊、this 與 object 鎖的本質區別

Java 多線程同步深度解析：synchronized 方法、同步塊、this 與 object 鎖的本質區別

synchronized 兩種基本形式

1. 同步方法

public synchronized void accessVal(int newVal) { ... }
public static synchronized void staticMethod() { ... }

• 實例方法：鎖對象為 this (當前實例)
• 靜態方法：鎖對象為 ClassName.class (類對象)
• 同一實例的所有同步方法共用一把鎖，同一時刻只能有一個線程執行任一同步方法

2. 同步塊

synchronized(syncObject) {
    // 受保護代碼
}

• syncObject 可為任意物件：this、其他實例、ClassName.class、字串常量、專用鎖物件
• 粒度更細，只鎖住關鍵代碼段，提升並發效能
• 靈活指定鎖對象，實現複雜同步協作

核心誤區與正解

誤區一：synchronized 只能用在 Thread/Runnable 相關類中

正解：synchronized 可用於任何類的方法/塊中。只要有多線程並發訪問共享資源，即需同步，與類是否繼承 Thread 或實現 Runnable 無關。

誤區二：synchronized(this) 與 synchronized(object) 作用範圍完全不同

正解：本質相同，鎖的是括號內的物件。差別在於鎖對象的選擇策略：

實戰代碼演示

共享資源類

public class SharedResource {
    public void methodA() {
        // synchronized(this) {  // 等價於方法加 synchronized
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " A i=" + i);
        }
        // }
    }
    public void methodB() {
        // synchronized(this) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " B i=" + i);
        }
        // }
    }
}

線程類：傳入共享資源，用資源實例作鎖

public class WorkerA implements Runnable {
    private final SharedResource resource;
    public WorkerA(SharedResource resource) { this.resource = resource; }
    @Override
    public void run() {
        synchronized (resource) { // 鎖住 resource 實例
            resource.methodA();
        }
    }
}

public class WorkerB implements Runnable {
    private final SharedResource resource;
    public WorkerB(SharedResource resource) { this.resource = resource; }
    @Override
    public void run() {
        synchronized (resource) { // 同一把鎖
            resource.methodB();
        }
    }
}

主程序啟動

public class Main {
    public static void main(String[] args) {
        SharedResource res = new SharedResource();
        new Thread(new WorkerA(res), "Thread-A").start();
        new Thread(new WorkerB(res), "Thread-B").start();
    }
}

執行結果分析

輸出將顯示 Thread-A 完整執行 100 次 methodA，隨後 Thread-B 執行 methodB（或相反順序），不會交叉輸出。因為兩線程競爭同一把鎖 (res 實例)。