synchronized工作原理(二)

  • 2020 年 3 月 10 日
  • 筆記

基於工作原理一可知同步關鍵字底層是基於JVM操作監視器的同步指令原語monitorenter和monitorexit來實現,這次將會通過抽象的內存語義來說明側面說明加鎖和解鎖的方式

1. 工作內存與主內存

定義

  • 主內存: 一般就是計算機操作系統上的物理內存,簡言之,即是一般我們所說的計算機的內存含義
  • 工作內存: 基於JMM(Java內存模型)規範規定,線程使用的變量將會把主內存的數據變量複製到自己線程棧的工作空間

線程工作內存與主內存的讀寫示意圖

前面已經有介紹到CPU高速緩存的知識點,以下是CPU簡單的架構圖以及工作內存與主內存的讀寫流程

從上述我們可以看到,CPU高速緩存包含L1-L3的Cache,線程每次讀寫都需要先經過CPU高速緩存,這樣便會產生數據緩存的不一致,前面已經有講到CPU廠商針對這類問題做了改進,運用緩存一致性來達到最終數據的一致性,那麼此時如果有一個需求是強一致性,即使是很短的時間內,我也需要保證寫數據之後立馬看到寫數據成功後的效果,這時候怎麼辦呢?在JMM規範中為了解決這類內存共享的數據在不同線程不可見的問題,就制定一種規範來強制java程序中的線程直接跳過CPU高速緩存數據去讀取主內存的數據,這就是解決內存數據的不可見的一種手段.

2. synchronized的代碼演示
  • 場景： 現在有一個共享變量sharedVar，thread-1執行寫操作需要耗時500ms，而有一個線程thread-2由於網絡原因延遲讀操作耗時600ms，另一個線程thread-3正常讀操作
  • 期望的場景是希望寫數據之後其他線程也知道數據已經發生改變了,需要讀取最新的數據
// Sync2memory.java  public class Sync2memory {        private static Integer sharedVar = 10;        public static void main(String[] args) throws Exception {          testForReadWrite();  //        testForReadWriteWithSync();   		TimeUnit.SECONDS.sleep(2L);          System.out.printf("finish the thread task,the final sharedVar %s ....n", sharedVar);      }        private static void testForReadWriteWithSync() throws Exception {          Thread thread1 = new Thread(new Runnable() {              @Override              public void run() {                  try {                  	// modify the sharedVar                      TimeUnit.MICROSECONDS.sleep(500L);                      synchronized (sharedVar){                          System.out.printf("%s modify the shared var ...n", "thread-1");                          sharedVar = 20;                      }                  }catch (Exception e){                      System.out.println(e);                  }              }          });              Thread thread2 = new Thread(new Runnable() {              @Override              public void run() {                  try {                     // network delay                     TimeUnit.MICROSECONDS.sleep(600L);                     synchronized (sharedVar){                         System.out.printf("%s read the shared var %s n", "thread-2", sharedVar);                     }                  }catch (Exception e){                      System.out.println(e);                  }              }          });            Thread thread3 = new Thread(new Runnable() {              @Override              public void run() {                  try {                      synchronized (sharedVar){                          System.out.printf("%s read the shared var %s n",  "thread-3", sharedVar);                      }                  }catch (Exception e){                      System.out.println(e);                  }              }          });            thread2.start();          thread3.start();          thread1.start();            thread1.join();          thread2.join();          thread3.join();      }        private static void testForReadWrite() throws Exception {          Thread thread1 = new Thread(new Runnable() {              @Override              public void run() {                  try {                  	// modify the sharedVar                      TimeUnit.MICROSECONDS.sleep(500L);                      System.out.printf("%s modify the shared var ...n", "thread-1");                      sharedVar = 20;                  }catch (Exception e){                      System.out.println(e);                  }              }          });              Thread thread2 = new Thread(new Runnable() {              @Override              public void run() {                  try {                  	// network delay                      TimeUnit.MICROSECONDS.sleep(600L);                      System.out.printf("%s read the shared var %s n", "thread-2", sharedVar);                  }catch (Exception e){                      System.out.println(e);                  }              }          });            Thread thread3 = new Thread(new Runnable() {              @Override              public void run() {                  try {                      System.out.printf("%s read the shared var %s n", "thread-3" , sharedVar);                  }catch (Exception e){                      System.out.println(e);                  }              }          });           //thread1-3 start and join ....      }  }
  • 沒有加synchronized方式的執行產生的一種結果(多次運行)
## 執行結果如下  thread-3 read the shared var 10  thread-1 modify the shared var to 20  ...  thread-2 read the shared var 10  finish the thread task,the final sharedVar 20 ....    Process finished with exit code 0    ## 分析  線程3正常執行,並且還沒有在發生寫操作之前就已經讀取數據,屬於正常輸出  線程1執行寫操作耗時500ms並將數據進行修改同步到主內存中  線程2由於網絡延遲600ms,但是此時寫操作已經完成,這時候讀取出來的數據是屬於臟數據,並不正確,因此線程2讀取是其還沒有被刷新的工作內存數據  最後看到執行的結果輸出是寫操作之後的數據,說明了CPU最終會保證緩存數據的一致性  最後的最後,這裡僅僅是闡述上述問題,上述運行結果也可能發生thread-2會讀取到正常的數據,只是在上述編碼情況我們是無法保證線程2一定可以讀取到正確的數據
  • 添加synchronized方式的執行結果(多次執行)
## 多次執行結果如下:  thread-3 read the shared var 10  thread-1 modify the shared var ...  thread-2 read the shared var 20  finish the thread task,the final sharedVar 20 ....    Process finished with exit code 0    ## 分析  線程1執行寫操作之後,我們可以看到線程2獲取到的數據是線程1執行寫操作之後的數據,現在程序可以保證線程2讀取的數據是正常的
3. synchronized內存語義的理解

內存語義小結

  • 基於上述代碼的執行結果可以看出,我們使用synchronized塊內的共享變量將從線程的工作內存中清除或者稱為失效,此時程序就不會從工作內存中進行讀取數據,而是直接從主內存中讀取數據,從而保證緩存數據的強一致性
  • 由此可知道,synchronized從內存語義上可以解決共享變量的內存可見性問題
  • 從另一個角度而言,使用synchronized相當於jvm獲取monitorenter的指令,此時會將該共享變量的緩存失效直接從主內存中加載數據到鎖塊的內存中,同時在進行monitorexit操作的指令時會將鎖塊的共享變量數據刷新到主內存中

synchronized不足

  • 使用monitor的方式是屬於metux lock的方式(重量級鎖),會降低程序的性能(響應時間可能會變慢,相當於利用性能來換取數據的強一致性問題)
  • 另外一個就是線程是由CPU進行調度,來回切換線程會帶來額外的調度開銷

謝謝閱讀,如果有幫助,歡迎轉發或者點擊好看,感謝!

VirMach 便宜 VPS

QNews

QNews