1. 介紹

在Java併發系列的文章中，這個是第二篇文章。在前面的一篇文章中，我們學習了Java中的Executor池和Excutors的各種類別。

在這篇文章中，我們會學習synchronized關鍵字以及我們在多執行緒的環境中如何使用。

2. 什麼是同步？

在一個多執行緒的環境中，多個執行緒同時訪問相同的資源的情況是存在的。例如，兩個執行緒試圖寫入同一個文字檔案。它們之間沒有任何的同步，當兩個或多個執行緒對同一檔案具有寫訪問權時，寫入該檔案的資料可能會損壞。
同理，在JVM中，每個執行緒在各自的棧上儲存了一份變數的副本。某些其他執行緒可能會更改這些變數的實際值。但是更改後的值可能不會重新整理到其他執行緒的本地副本中。

這可能導致程式執行錯誤和非確定性行為。

為了避免這種問題，Java給我們提供了synchronized這有助於實現執行緒之間的通訊，使得只有一個執行緒訪問同步資源，而其他執行緒等待資源變為空閒。

synchronized關鍵字可以被用在下面一些不同的方式中，比如一個同步塊:

synchronized(someobject){
    //thread-safe code here
}

對方法進行同步：

public synchronized void someMethod(){
    //thread-safe code here
}

3.在JVM中synchronized是如何實現的

當一個執行緒試圖進入一個同步塊或者同步方法中的時候，它必須先獲得一個同步物件上的鎖。一次只可以有一個執行緒獲取鎖，並且執行塊中的程式碼。

如果其他執行緒嘗試訪問該同步塊，則必須等待，直到當前執行緒執行完同步塊的程式碼。當前執行緒退出後，鎖將被自動釋放，其它執行緒可以獲取鎖並進入同步程式碼塊。

• 對於一個synchronized塊來說，在synchronized關鍵字後的括號中指定的物件上獲取鎖；
• 對於一個synchronized static方法，鎖是在.class物件上獲取的；
• 對於synchronized例項方法來說，鎖定是在該類的當前例項上獲得的，即該例項(this)；

4.同步方法

定義同步方法就像在返回型別之前簡單地包含關鍵字一樣簡單。我們定義一個順序列印數字1-5之間的方法。會有兩個執行緒來訪問這個方法，所以讓我們來看看在沒有使用synchronized關鍵字它們的執行情況， 和我們使用關鍵字來鎖住共享物件會發生什麼：

public class NonSynchronizedMethod {

    public void printNumbers() {
        System.out.println("Starting to print Numbers for " + Thread.currentThread().getName());

        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }

        System.out.println("Completed printing Numbers for " + Thread.currentThread().getName());
    }
}

現在，讓我們實現兩個訪問該物件並希望執行 printNumbers() 方法的自定義執行緒：

class ThreadOne extends Thread {

    NonSynchronizedMethod nonSynchronizedMethod;

    public ThreadOne(NonSynchronizedMethod nonSynchronizedMethod) {
        this.nonSynchronizedMethod = nonSynchronizedMethod;
    }

    @Override
    public void run() {
        nonSynchronizedMethod.printNumbers();
    }
}

class ThreadTwo extends Thread {

    NonSynchronizedMethod nonSynchronizedMethod;

    public ThreadTwo(NonSynchronizedMethod nonSynchronizedMethod) {
        this.nonSynchronizedMethod = nonSynchronizedMethod;
    }

    @Override
    public void run() {
        nonSynchronizedMethod.printNumbers();
    }
}

這些執行緒共享一個相同的物件NonSynchronizedMethod,它們會在這個物件上同時去呼叫非同步的方法printNumbers()。

為了測試這個，寫一個main方法來做測試：

public class TestSynchronization {  
    public static void main(String[] args) {

        NonSynchronizedMethod nonSynchronizedMethod = new NonSynchronizedMethod();

        ThreadOne threadOne = new ThreadOne(nonSynchronizedMethod);
        threadOne.setName("ThreadOne");

        ThreadTwo threadTwo = new ThreadTwo(nonSynchronizedMethod);
        threadTwo.setName("ThreadTwo");

        threadOne.start();
        threadTwo.start();

    }
}

執行上面的程式碼，我們會得到下面的結果：

Starting to print Numbers for ThreadOne  
Starting to print Numbers for ThreadTwo  
ThreadTwo 0  
ThreadTwo 1  
ThreadTwo 2  
ThreadTwo 3  
ThreadTwo 4  
Completed printing Numbers for ThreadTwo  
ThreadOne 0  
ThreadOne 1  
ThreadOne 2  
ThreadOne 3  
ThreadOne 4  
Completed printing Numbers for ThreadOne

雖然ThreadOne先開始執行的，但是ThreadTwo先結束的。

當我們再次執行上面的程式的時候，我們會得到一個不同的結果：

Starting to print Numbers for ThreadOne  
Starting to print Numbers for ThreadTwo  
ThreadOne 0  
ThreadTwo 0  
ThreadOne 1  
ThreadTwo 1  
ThreadOne 2  
ThreadTwo 2  
ThreadOne 3  
ThreadOne 4  
ThreadTwo 3  
Completed printing Numbers for ThreadOne  
ThreadTwo 4  
Completed printing Numbers for ThreadTwo

這些輸出完全是偶然的，完全不可預測。每次執行都會給我們一個不同的輸出。因為可以有更多的執行緒，我們可能會遇到問題。在實際場景中，在訪問某種型別的共享資源（如檔案或其他型別的IO）時，這一點尤為重要，而不是僅僅列印到控制檯。

下面我們採用同步的方法，使用synchronized關鍵字：

public synchronized void printNumbers() {  
    System.out.println("Starting to print Numbers for " + Thread.currentThread().getName());

    for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName() + " " + i);
    }

    System.out.println("Completed printing Numbers for " + Thread.currentThread().getName());
}

程式碼中只是給方法添加了一個synchronized關鍵字，沒有其它的改動。現在我們執行上面的程式碼，得到如下所示的結果：

Starting to print Numbers for ThreadOne  
ThreadOne 0  
ThreadOne 1  
ThreadOne 2  
ThreadOne 3  
ThreadOne 4  
Completed printing Numbers for ThreadOne  
Starting to print Numbers for ThreadTwo  
ThreadTwo 0  
ThreadTwo 1  
ThreadTwo 2  
ThreadTwo 3  
ThreadTwo 4  
Completed printing Numbers for ThreadTwo

在這裡，我們看到即使兩個執行緒同時執行，只有一個執行緒一次進入synchronized方法，在這種情況下是ThreadOne。一旦完成執行，ThreadTwo就可以執行printNumbers()方法

5.同步塊

多執行緒的主要目的是儘可能並行地執行任意數量的任務。但是，同步限制了必須執行同步方法或塊的執行緒的並行性。

但是，我們可以嘗試通過在同步範圍內保留儘可能少的程式碼來減少以同步方式執行的程式碼量。可能有許多場景，不是在整個方法上同步，而是可以在方法中同步幾行程式碼。

我們可以使用synchronized塊來包含程式碼的那部分而不是整個方法。也就是說對於需要同步的程式碼塊進行同步，而不是對整個方法進行同步。

由於在同步塊內部執行的程式碼量較少，因此每個執行緒都會更快地釋放鎖定。結果，其他執行緒花費更少的時間等待鎖定並且程式碼吞吐量大大增加。

讓我們修改前面的例子，只同步for迴圈列印數字序列，實際上，它是我們示例中應該同步的唯一程式碼部分：

public class SynchronizedBlockExample {
    public void printNumbers() {
        System.out.println("Starting to print Numbers for " + Thread.currentThread().getName());
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
        System.out.println("Completed printing Numbers for " + Thread.currentThread().getName());
    }
}

執行結果：

Starting to print Numbers for ThreadOne  
Starting to print Numbers for ThreadTwo  
ThreadOne 0  
ThreadOne 1  
ThreadOne 2  
ThreadOne 3  
ThreadOne 4  
Completed printing Numbers for ThreadOne  
ThreadTwo 0  
ThreadTwo 1  
ThreadTwo 2  
ThreadTwo 3  
ThreadTwo 4  
Completed printing Numbers for ThreadTwo

儘管ThreadTwo在ThreadOne完成其任務之前“開始”列印數字似乎令人擔憂，這只是因為我們在停止ThreadTwo鎖之前，允許執行緒通過System.out.println（"Completed printing Numbers for " + Thread.currentThread().getName()）語句。

這很好，因為我們只想同步每個執行緒中的數字序列。我們可以清楚地看到兩個執行緒只是通過同步for迴圈以正確的順序列印數字。

6.結論

在這個例子中，我們看到了如何在Java中使用synchronized關鍵字來實現多個執行緒之間的同步。我們還通過例子瞭解了何時可以使用synchronized方法和塊。

與往常一樣，您可以找到此示例中使用的程式碼

原文：https://stackabuse.com/synchronized-keyword-in-java/

 

作者：Chandan Singh

 

譯者：lee

相關推薦