萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 腳本程式專題 >> JavaScript

Java 多執行緒同步機制詳解:對象鎖與 synchronized 實戰

核心概念:對象鎖

Java 多執行緒同步依賴對象鎖機制。每個 Java 物件天生擁有一把鎖,synchronized 關鍵字正是透過獲取/釋放這把鎖來實現對共享資源的互斥訪問。

錯誤示範:鎖住 this 導致同步失效

class MyThread implements Runnable {
    private int threadId;
    public MyThread(int id) { this.threadId = id; }

    @Override
    public synchronized void run() { // 鎖住 this(當前 Runnable 實例)
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread ID: " + threadId + " : " + i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(new MyThread(i)).start(); // 每次 new 新 Runnable,鎖不同
            Thread.sleep(1);
        }
    }
}

結果:10 個執行緒各自持有不同實例的鎖,無法互斥,輸出交錯亂序。

正確做法一:共享外部鎖對象

class MyThread implements Runnable {
    private int threadId;
    private final Object lock; // 共享鎖

    public MyThread(int id, Object lock) {
        this.threadId = id;
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) { // 競爭同一把鎖
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread ID: " + threadId + " : " + i);
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Object sharedLock = new Object(); // 唯一共享鎖
        for (int i = 0; i < 10; i++) {
            new Thread(new MyThread(i, sharedLock)).start();
            Thread.sleep(1);
        }
    }
}

關鍵:所有執行緒共享同一個 Object 實例作為鎖。

正確做法二:靜態成員鎖(類級別鎖)

class MyThread implements Runnable {
    private int threadId;
    private static final Object LOCK = new Object(); // 類級別共享鎖

    public MyThread(int id) { this.threadId = id; }

    @Override
    public void run() {
        synchronized (LOCK) { // 所有實例共享同一把靜態鎖
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread ID: " + threadId + " : " + i);
            }
        }
    }
}

靜態欄位屬於類,所有實例天然共享,無需透過建構子傳遞。

正確做法三:靜態同步方法(鎖住 Class 物件)

class MyThread implements Runnable {
    private int threadId;
    public MyThread(int id) { this.threadId = id; }

    @Override
    public void run() {
        taskHandler(threadId); // 呼叫靜態同步方法
    }

    // 靜態方法鎖住 MyThread.class
    private static synchronized void taskHandler(int threadId) {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread ID: " + threadId + " : " + i);
        }
    }
}

static synchronized 等同於 synchronized(MyThread.class),鎖住的是類物件。

鎖對象對照表

同步方式鎖對象適用場景
synchronized instanceMethod()當前實例 this保護實例欄位
synchronized(this) { ... }當前實例 this同步塊,縮小鎖範圍
synchronized(sharedObj) { ... }外部共享物件多實例協作、跨類同步
static synchronized method()當前類 Class 物件保護靜態欄位、類級資源
synchronized(MyClass.class) { ... }指定類 Class 物件靜態同步塊、跨類靜態協作

最佳實踐原則

  1. 縮小鎖範圍:優先使用同步塊而非同步方法,只鎖保護共享資源的必要代碼
  2. 使用 final 鎖對象:防止鎖引用被意外修改導致同步失效
  3. 避免鎖住公開物件:如 String 常量、Integer 等可能被外部代碼同步導致死鎖
  4. 考慮 java.util.concurrent:ReentrantLock、ReadWriteLock、ConcurrentHashMap 等高級工具往往比 synchronized 更靈活高效

總結

Java 同步的本質是多執行緒競爭同一把鎖。理解鎖對象的選擇與生命週期,是編寫正確併發程式的基石。錯誤的鎖選擇(如每個執行緒各自的 this)是新手最常見的 Bug 來源。

copyright © 萬盛學電腦網 all rights reserved