synchronized 作為悲觀鎖，鎖住了什麼？

LieBrother發表於2020-04-27

繼續來認識 synchronized，上篇文章加不加 synchronized 有什麼區別？我們瞭解了 synchronized 是在多執行緒併發競爭同一資源的時候使用，這一篇我們來了解，synchronized 作為悲觀鎖，鎖住了什麼？

鎖例項物件

上篇文章我們就有鎖例項物件的程式碼樣例，只是當時沒有細說這個概念。我們再寫一個程式碼來測試一下。程式碼邏輯是這樣的：我們寫 2 個 synchronized 例項方法，讓 5 個執行緒隨機執行 2 個方法。程式碼如下：

只有一個例項物件的情況：

public class SynchronizedTest {

    public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        for (int i = 0; i < 5; i++) {
            int thisi = i;
            Thread thread = new Thread(() -> {
                if (thisi % 2 == 0) {
                    synchronizedTest.testSynchronizedMethod1();
                } else {
                    synchronizedTest.testSynchronizedMethod2();
                }
            });
            thread.start();
        }
    }

    public synchronized void testSynchronizedMethod1() {
        System.out.printf("%s-testSynchronizedMethod1-start-count=%s\n", Thread.currentThread().getName(), count);
        count ++;
        System.out.printf("%s-testSynchronizedMethod1-end-count=%s\n", Thread.currentThread().getName(), count);
    }

    public synchronized void testSynchronizedMethod2() {
        System.out.printf("%s-testSynchronizedMethod2-start-count=%s\n", Thread.currentThread().getName(), count);
        count ++;
        System.out.printf("%s-testSynchronizedMethod2-end-count=%s\n", Thread.currentThread().getName(), count);
    }
}

執行結果：

這份程式碼裡面有 5 個執行緒競爭一個 synchronizedTest 資源，所以只能序列跑，我們這裡用了 2 個方法，為了讓大家更清楚的明白鎖的是物件，而不是鎖物件裡面的某個方法。如果是鎖方法，那麼執行緒Thread-0呼叫testSynchronizedMethod1方法和執行緒Thread-1呼叫testSynchronizedMethod2方法就不會序列執行，會併發執行；但是結果是序列執行，也就驗證了是鎖 synchronizedTest 物件而不是方法。通過 count 結果，更加清晰的瞭解，方法是序列執行的。

每個執行緒一個例項物件的情況：

public class SynchronizedTest {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            SynchronizedTest synchronizedTest = new SynchronizedTest();
            int thisi = i;
            Thread thread = new Thread(() -> {
                if (thisi % 2 == 0) {
                    synchronizedTest.testSynchronizedMethod1();
                } else {
                    synchronizedTest.testSynchronizedMethod2();
                }
            });
            thread.start();
        }
    }

    public synchronized void testSynchronizedMethod1() {
        System.out.printf("%s-testSynchronizedMethod1-start-count=%s\n", Thread.currentThread().getName(), count);
        count ++;
        System.out.printf("%s-testSynchronizedMethod1-end-count=%s\n", Thread.currentThread().getName(), count);
    }

    public synchronized void testSynchronizedMethod2() {
        System.out.printf("%s-testSynchronizedMethod2-start-count=%s\n", Thread.currentThread().getName(), count);
        count ++;
        System.out.printf("%s-testSynchronizedMethod2-end-count=%s\n", Thread.currentThread().getName(), count);
    }
}

這份程式碼是每個執行緒有獨立的物件，執行緒之間沒有競爭，所以互不影響，count 也都是執行緒獨立的，所以 end 結果都是 1。這個例子為了和下面的鎖類的 Class 物件做對比，先記住鎖例項物件的情況，只要執行緒之間鎖的不是同一個例項物件，執行緒之間就沒有競爭。

鎖類的 Class 物件

我們將本來例項方法改成 static 靜態方法，這份程式碼 IDE 會提示異常，我們先忽略異常，可以執行成功。

public class SynchronizedTest {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            SynchronizedTest synchronizedTest = new SynchronizedTest();
            Thread thread = new Thread(() -> {
                synchronizedTest.testSynchronizedStaticMethod();
            });
            thread.start();
        }
    }
    
    public static synchronized void testSynchronizedStaticMethod() {
        System.out.println("testSynchronizedStaticMethod-start-" + Thread.currentThread().getName());
        System.out.println("testSynchronizedStaticMethod-end-" + Thread.currentThread().getName());
    }
}

程式碼結果：