一個例子看懂Java中synchronized關鍵字到底怎麼用

本篇文章給大家帶來了關於的相關知識，其中主要介紹了關於synchronized關鍵字的相關問題，包括了使用同步方法、使用同步語句或塊以及什麼是同步、為什麼需要同步的相關內容，下面一起來看一下，希望對大家有幫助。

程式設計師必備介面測試偵錯工具：

推薦學習：《》

在平時開發中，synchronized關鍵字經常遇到，你知道synchronized怎麼用嗎？本文給大家介紹一下。

我們有兩種方法使用同步：

使用同步方法
使用同步語句或塊

使用同步方法

要使方法同步，只需將synchronized關鍵字新增到其宣告中：

public class SynchronizedDemo {

    private int i = 0;

    public synchronized void add() {
        i++;
    }

    public synchronized void del() {
        i--;
    }

    public synchronized int getValue() {
        return i;
    }
}
登入後複製

如上程式碼顯示，一共有三個同步方法：

add()
del()
getValue()

每個方法同一個物件同一時刻只會被呼叫一次，比如一個執行緒在呼叫add()時，其他執行緒都會被阻塞，直到第一個執行緒處理完add()方法。

使用同步語句或塊

    public void del(int value){

        synchronized(this){
            this.i -= value;
        }
    }
登入後複製

如上程式碼，synchronized加在了一個{}程式碼前，這個就代表是一個同步程式碼塊。

以上就是synchronized關鍵字兩種使用方法，下面我們來簡單的介紹一下同步相關的概念。

什麼是同步？

同步是一個控制多個執行緒存取任何共用資源的程序，可以避免不一致的結果。使用同步的主要目的是避免執行緒的不一致行為，防止執行緒干擾。

在java中可以使用synchronized 關鍵字實現同步的效果，synchronized只能應用於方法和塊，不能應用於變數和類。

為啥需要同步？

首先我們來看一段程式碼：

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        System.out.println("計算值為：" + synchronizedDemo.i);
    }
}
登入後複製

每當呼叫increment()方法時計算值都會加1：

呼叫2次就會加2，呼叫3次就會加3，呼叫4次就會加4：

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        System.out.println("計算值為：" + synchronizedDemo.i);
    }
}
登入後複製

現在我們擴充套件一下上面的例子，建立一個執行緒去呼叫10次increment()方法：

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronizedDemo.increment();
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("計算值為：" + synchronizedDemo.i);
    }
}
登入後複製

此時計算的結果正如我們預料的那樣，結果為10.

這是單執行緒的情況，一切都是如此的美好，但是事實真的如此嗎？如果是多執行緒環境，會是什麼樣的？

下面我們來演示一下多執行緒的情況！

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("計算值為：" + synchronizedDemo.i);
    }
}
登入後複製

如上程式碼，我們建立了兩個執行緒 thread1 和 thread2，每個執行緒呼叫1000次increment()，理論上最終列印的值應該是2000，因為thread1呼叫increment()1000次後值會變成1000，thread2呼叫increment()1000次後值會變成2000.

我們執行一下，看看結果：

結果和我們想的不一樣，小於2000，我們再執行一下：

結果還是小於2000.

這是為什麼呢？

因為多執行緒支援並行處理，因此，兩個執行緒總是有可能同時獲取計數器的值，因此都得到相同的計數器值，所以在這種情況下，不是遞增計數器的值兩次，只增加一次。

那麼，如何避免這種情況呢？

使用 synchronized 關鍵字即可解決。

我們只需要將increment()方法加上synchronized就可以了：

public class SynchronizedDemo {

    int i;

    public synchronized void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("計算值為：" + synchronizedDemo.i);
    }
}
登入後複製

這個時候我們再執行一下：

可以看到，值為2000.

我們把計算次數提高到10000次：

public class SynchronizedDemo {

    int i;

    public synchronized void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("計算值為：" + synchronizedDemo.i);
    }
}
登入後複製

執行結果為：

可以看出，一個小小的synchronized竟然那麼簡單的就解決了這個問題。

這個背後的原理就是執行緒1執行increment()方法時，因為有synchronized，所以會自動將此方法加鎖，而此時只有執行緒1擁有這把鎖，其他執行緒只能等待，直到執行緒1釋放這把鎖，執行緒2才能參與呼叫。

同理，當執行緒2去呼叫increment()時，執行緒2拿到鎖，執行緒1進入等待，直到執行緒2釋放鎖，就這樣，直到計算完畢，在此過程中，不會出現計算錯誤的情況。

總結

synchronized 關鍵字是使塊或方法同步的唯一方法。
synchronized 關鍵字提供了鎖的特性，它確保執行緒之間不會出現競爭條件。被鎖定後，執行緒只能從主記憶體中讀取資料，讀取資料後，它會重新整理寫操作，然後才能釋放鎖。
synchronized 關鍵字還有助於避免程式語句的重新排序。

推薦學習：《》

以上就是一個例子看懂Java中synchronized關鍵字到底怎麼用的詳細內容，更多請關注TW511.COM其它相關文章！