快捷導(dǎo)航

一個(gè)例子帶你看懂Java中synchronized關(guān)鍵字到底怎么用

更新時(shí)間：2022年10月05日 10:36:31 作者：wljslmz

synchronized是Java里的一個(gè)關(guān)鍵字,起到的一個(gè)效果是"監(jiān)視器鎖",它的功能就是保證操作的原子性,同時(shí)禁止指令重排序和保證內(nèi)存的可見性,下面這篇文章主要給大家介紹了關(guān)于如何通過一個(gè)例子帶你看懂Java中synchronized關(guān)鍵字到底怎么用的相關(guān)資料,需要的朋友可以參考下

前言

在平時(shí)開發(fā)中，synchronized關(guān)鍵字經(jīng)常遇到，你知道synchronized怎么用嗎？本文給大家介紹一下。

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

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

使用同步方法

要使方法同步，只需將synchronized關(guān)鍵字添加到其聲明中：

public class SynchronizedDemo {

    private int i = 0;

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

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

    public synchronized int getValue() {
        return i;
    }
}

如上代碼顯示，一共有三個(gè)同步方法：

add()
del()
getValue()

每個(gè)方法同一個(gè)對(duì)象同一時(shí)刻只會(huì)被調(diào)用一次，比如一個(gè)線程在調(diào)用add()時(shí)，其他線程都會(huì)被阻塞，直到第一個(gè)線程處理完add()方法。

使用同步語句或塊

    public void del(int value){

        synchronized(this){
            this.i -= value;
        }
    }

如上代碼，synchronized加在了一個(gè){}代碼前，這個(gè)就代表是一個(gè)同步代碼塊。

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

什么是同步？

同步是一個(gè)控制多個(gè)線程訪問任何共享資源的進(jìn)程，可以避免不一致的結(jié)果。使用同步的主要目的是避免線程的不一致行為，防止線程干擾。

在java中可以使用synchronized 關(guān)鍵字實(shí)現(xiàn)同步的效果，synchronized只能應(yīng)用于方法和塊，不能應(yīng)用于變量和類。

為啥需要同步？

首先我們來看一段代碼：

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

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

每當(dāng)調(diào)用increment()方法時(shí)計(jì)算值都會(huì)加1：

調(diào)用2次就會(huì)加2，調(diào)用3次就會(huì)加3，調(diào)用4次就會(huì)加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("計(jì)算值為：" + synchronizedDemo.i);
    }
}

現(xiàn)在我們擴(kuò)展一下上面的例子，創(chuàng)建一個(gè)線程去調(diào)用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("計(jì)算值為：" + synchronizedDemo.i);
    }
}

此時(shí)計(jì)算的結(jié)果正如我們預(yù)料的那樣，結(jié)果為10.

這是單線程的情況，一切都是如此的美好，但是事實(shí)真的如此嗎？如果是多線程環(huán)境，會(huì)是什么樣的？

下面我們來演示一下多線程的情況！

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("計(jì)算值為：" + synchronizedDemo.i);
    }
}

如上代碼，我們創(chuàng)建了兩個(gè)線程 thread1 和 thread2，每個(gè)線程調(diào)用1000次increment()，理論上最終打印的值應(yīng)該是2000，因?yàn)閠hread1調(diào)用increment()1000次后值會(huì)變成1000，thread2調(diào)用increment()1000次后值會(huì)變成2000.

我們執(zhí)行一下，看看結(jié)果：

結(jié)果和我們想的不一樣，小于2000，我們?cè)賵?zhí)行一下：

結(jié)果還是小于2000.

這是為什么呢？

因?yàn)槎嗑€程支持并行處理，因此，兩個(gè)線程總是有可能同時(shí)獲取計(jì)數(shù)器的值，因此都得到相同的計(jì)數(shù)器值，所以在這種情況下，不是遞增計(jì)數(shù)器的值兩次，只增加一次。

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

使用 synchronized 關(guān)鍵字即可解決。

我們只需要將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("計(jì)算值為：" + synchronizedDemo.i);
    }
}

這個(gè)時(shí)候我們?cè)賵?zhí)行一下：

可以看到，值為2000.

我們把計(jì)算次數(shù)提高到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("計(jì)算值為：" + synchronizedDemo.i);
    }
}

執(zhí)行結(jié)果為：

可以看出，一個(gè)小小的synchronized竟然那么簡(jiǎn)單的就解決了這個(gè)問題。

這個(gè)背后的原理就是線程1執(zhí)行increment()方法時(shí)，因?yàn)橛衧ynchronized，所以會(huì)自動(dòng)將此方法加鎖，而此時(shí)只有線程1擁有這把鎖，其他線程只能等待，直到線程1釋放這把鎖，線程2才能參與調(diào)用。

同理，當(dāng)線程2去調(diào)用increment()時(shí)，線程2拿到鎖，線程1進(jìn)入等待，直到線程2釋放鎖，就這樣，直到計(jì)算完畢，在此過程中，不會(huì)出現(xiàn)計(jì)算錯(cuò)誤的情況。

總結(jié)

synchronized 關(guān)鍵字是使塊或方法同步的唯一方法。
synchronized 關(guān)鍵字提供了鎖的特性，它確保線程之間不會(huì)出現(xiàn)競(jìng)爭(zhēng)條件。被鎖定后，線程只能從主存中讀取數(shù)據(jù)，讀取數(shù)據(jù)后，它會(huì)刷新寫操作，然后才能釋放鎖。
synchronized 關(guān)鍵字還有助于避免程序語句的重新排序。

到此這篇關(guān)于Java中synchronized關(guān)鍵字到底怎么用的文章就介紹到這了,更多相關(guān)Java中synchronized關(guān)鍵字使用內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: