java中synchronized關鍵字的3種寫法實例

Posted on by

預備知識

首先，我們得知道在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來禁用偏向鎖。

總結

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

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

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

推薦閱讀：