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

繼續來認識 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());
    }
}

程式碼結果：