java中synchronized關鍵字的3種寫法分別是什么

java中synchronized關鍵字的3種寫法分別是什么，針對這個問題，這篇文章詳細介紹了相對應的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

預備知識

首先，我們得知道在java中存在三種變量：

• 實例變量 ==》 存在于堆中

• 靜態變量 ==》 存在于方法區中

• 局部變量 ==》 存在于棧中

然后，我們得明白，合適會發生高并發不安全

• 條件1：多線程并發。

• 條件2：有共享數據。

• 條件3：共享數據有修改的行為。

具體不安全案例請參考 如下這篇文章：java線程安全問題詳解

在上面這篇文章銀行取錢案例中，我們解決線程安全問題的方法是加了一個 synchronized 關鍵字。下面我們就詳細介紹一下 synchronized 的三種寫法，分別解決什么問題！！！

寫法一：修飾代碼塊

package ThreadSafa;
 
public class Test {
    public static void main(String[] args) {
        TestAccount ta1 = new TestAccount();
        ta1.setNum(10);
 
        //共用一個賬戶對象
        TestThread t1 = new TestThread(ta1);
        TestThread t2 = new TestThread(ta1);
        t1.start();
        t2.start();
    }
}
 
class TestThread extends Thread {
 
    private TestAccount mAccount;
 
    public TestThread(TestAccount mAccount) {
        this.mAccount = mAccount;
    }
 
    @Override
    public void run() {
        mAccount.updateNum(1);
    }
}
 
class TestAccount {
    private double num;
 
    public double getNum() {
        return num;
    }
 
    public void setNum(double num) {
        this.num = num;
    }
 
    public void updateNum(int n) {
        synchronized (this) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            setNum(getNum() - n);
        }
        System.out.println(getNum());
    }
}

運行結果

 寫法二：修飾方法

package ThreadSafa;
 
public class Test {
    public static void main(String[] args) {
        TestAccount ta1 = new TestAccount();
        ta1.setNum(10);
 
        TestThread t1 = new TestThread(ta1);
        TestThread t2 = new TestThread(ta1);
        t1.start();
        t2.start();
    }
}
 
class TestThread extends Thread {
 
    private TestAccount mAccount;
 
    public TestThread(TestAccount mAccount) {
        this.mAccount = mAccount;
    }
 
    @Override
    public void run() {
        mAccount.updateNum(1);
    }
}
 
class TestAccount {
    private double num;
 
    public double getNum() {
        return num;
    }
 
    public void setNum(double num) {
        this.num = num;
    }
 
    public synchronized void updateNum(int n) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setNum(getNum() - n);
        System.out.println(getNum());
    }
}

運行結果

總結

可以看到 ，前面這兩種寫法其實是等價的，什么意思呢？就是當你用 synchronized 修飾共享對象 this 的時候 你就可以吧 synchronized 提到方法前面，但是我們一般不會這么干，因為擴大 synchronized 修飾的代碼范圍會使代碼運行效率降低。

同時，前面兩種方法都是為了解決 實例變量 線程安全問題而誕生的，對于靜態變量我們怎么處理呢？請看寫法三：

寫法三：修飾靜態方法

package ThreadSafa;
 
public class Test {
    public static void main(String[] args) {
        TestAccount ta1 = new TestAccount();
        TestAccount ta2 = new TestAccount();
 
        TestThread t1 = new TestThread(ta1);
        TestThread t2 = new TestThread(ta2);
        t1.start();
        t2.start();
    }
}
 
class TestThread extends Thread {
 
    private TestAccount mAccount;
 
    public TestThread(TestAccount mAccount) {
        this.mAccount = mAccount;
    }
 
    @Override
    public void run() {
        mAccount.updateCount(1);
    }
}
 
class TestAccount {
    private double num;
    public static double count = 10;
 
    public double getNum() {
        return num;
    }
 
    public void setNum(double num) {
        this.num = num;
    }
 
    public synchronized void updateNum(int n) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setNum(getNum() - n);
        System.out.println(getNum());
    }
 
    public synchronized static void updateCount(int n) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count -= n;
        System.out.println(count);
    }
}

運行結果展示

可以看到，在靜態方法上加 synchronized 之后，他鎖的是這個類，盡管兩個賬戶對象不一樣，但是，加了 synchronized 會保證他們排隊執行，也就是保證了線程安全。

synchronized原理

Synchronized是通過對象內部的一個叫做監視器鎖（monitor）來實現的。但是監視器鎖本質又是依賴于底層的操作系統的互斥鎖（Mutex Lock）來實現的。而操作系統實現線程之間的切換這就需要從用戶態轉換到核心態，這個成本非常高，狀態之間的轉換需要相對比較長的時間，這就是為什么Synchronized效率低的原因。這種依賴于操作系統互斥鎖（Mutex Lock）所實現的鎖我們稱之為“重量級鎖”。

1. monitor鎖定過程

當monitor被占用時就會處于鎖定狀態，線程執行monitorenter指令時嘗試獲取monitor的所有權，過程如下：

a、如果monitor的進入數為0，則該線程進入monitor，然后將進入數設置為1，該線程即為monitor的所有者。

b、如果線程已經占有該monitor，只是重新進入，則進入monitor的進入數加1.

c、如果其他線程已經占用了monitor，則該線程進入阻塞狀態，直到monitor的進入數為0，再重新嘗試獲取monitor的所有權。

2. synchronized鎖

Java SE1.6對Synchronized進行了各種優化之后，它并不那么重了。在不同的場景中引入不同的鎖優化。

1.偏向鎖：適用于鎖沒有競爭的情況，假設共享變量只有一個線程訪問。如果有其他線程競爭鎖，鎖則會膨脹成為輕量級鎖。

2.輕量級鎖：適用于鎖有多個線程競爭，但是在一個同步方法塊周期中鎖不存在競爭，如果在同步周期內有其他線程競爭鎖，鎖會膨脹為重量級鎖。

3.重量級鎖：競爭激烈的情況下使用重量級鎖。

偏向鎖和輕量級鎖之所以會在性能上比重量級鎖是因為好，本質上是因為偏向鎖和輕量級鎖僅僅使用了CAS。

3. synchronized鎖優化

盡量采用輕量級鎖和偏向鎖等對Synchronized的優化，但是這兩種鎖也不是完全沒缺點的，比如競爭比較激烈的時候，不但無法提升效率，反而會降低效率，因為多了一個鎖升級的過程，這個時候就需要通過-XX:-UseBiasedLocking來禁用偏向鎖。

總結

局部變量 =》 存在于棧中 =》 線程之間不能共享 =》 所以數據永遠是安全的

實例變量 =》 存在于堆中 =》 線程之間能共享 =》 采用寫法一和寫法二保證線程安全

靜態變量 =》 存在于方法區 =》 線程之間能共享 =》 采用方寫法三保證線程安全

關于java中synchronized關鍵字的3種寫法分別是什么問題的解答就分享到這里了，希望以上內容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關注億速云行業資訊頻道了解更多相關知識。