Java Synchronize下的volatile關鍵字詳解

Posted on by

簡介關鍵詞：Synchronize與volatile

  • Synchronize：無論是對於Synchronize同步方法異或是Synchronize塊，本質是對某對象或某類加鎖，讓多線程進行隊列化的有序地同步執行。
  • volatile：用於修飾變量。在多線程執行過程中，禁止線程從工作內存（緩存）中讀取值。

volatile問題拋出：

讓我們看到這樣一個問題，我們設置一個含有boolean標志位的類Test，以及兩個Runable接口實例，分別為MyThread1,MyThread2。
在MyThread1中通過while循環判斷flag是否更改，如果更改便結束循環退出。
在MyThread2中改變flag值。
代碼如下：
Test：

public class Test {
 boolean flag = true;
}

MyThread1：

public class MyThread1 implements Runnable{

 Test test;

 public MyThread1(Test test){
  this.test = test;
 }

 @Override
 public void run() {

  while (test.flag){

  }

  System.out.println(Thread.currentThread().getName()+" 我已退出");
 }

}

MyThread2：

public class MyThread2 implements Runnable{

 Test test;

 public MyThread2(Test test){
  this.test = test;
 }

 @Override
 public void run() {

  try {
   Thread.sleep(3000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }

  test.flag = false;

 }
}

main函數：

public static void main(String[] args) {

 Test test = new Test();

 MyThread1 myThread1 = new MyThread1(test);
 MyThread2 myThread2 = new MyThread2(test);

 Thread thread1 = new Thread(myThread1);
 Thread thread2 = new Thread(myThread2);

 thread1.start();
 try {
  Thread.sleep(1000);
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 thread2.start();

}
  • 按照我們常規的想法，在在Sleep延時之後，Thread2會更改flag的值。而Thread1也會因此退出循環。
  • 但實際上，Thread1並沒有因此退出循環。
  • 原因是Thread1並未從內存中讀取flag，而是直接從工作內存中讀取。所以即便是Thread2已經更新瞭flag的值，但Thread1工作內存中的flag也並未更新。所以便導致瞭Thread1陷入死循環。

該圖片來自於Java 並發：volatile 關鍵字解析

 

解決方法：

那麼如何解決這樣的問題呢？
很簡單，使用volatile關鍵字。讓線程不得不從主內存中讀取flag值。

volatile boolean flag = true;

在我們添加volatile關鍵字後，Thread1便可以正常退出。

在Synchronize下的volatile：

此時我們已經瞭解瞭volatile關鍵字的作用，那麼在我們的volatile關鍵字中，Synchronize有著怎樣的作用呢？

volatile問題拋出：

其實在我們實際使用中，volatile其實也是有一些隱患的。
例如：我們創造10條線程，每條線程都使volatile修飾的int常量增加1000000次。

public class MyThread1 implements Runnable{

 volatile int num = 0;

 @Override
 public void run() {

  for (int i = 0; i < 1000000; i++) {
   num++;
   System.out.println(Thread.currentThread().getName()+" "+num);
  }

 }

 public static void main(String[] args) {

  MyThread1 myThread1 = new MyThread1();

  Thread[] arr = new Thread[10];

  for (int i = 0; i < 10; i++) {
   arr[i] = new Thread(myThread1);
  }

  for (int i = 0; i < 10; i++) {
   arr[i].start();
  }

 }

}

輸出結果

分析：

  • 從結果中，我們可以看到，num並沒有像我們想象一樣達到10000000。
  • 這是因為volatile所修飾的int變量在自加過程中並非原子操作。這也就是說這個自加的過程可以被打斷。可以被分解為：獲取值，自加，賦值三個步驟。
  • 例如當，num = 0時，Thread1獲取瞭num的值，並賦值為1，但此時在Thread1還未來得及更新線程的時候，Thread的2以及Thread3已經將線程的值更新為2，但Thread1再賦值，num的值又會重新變為1。
  • 所以，我們便需要在自加的過程中添加Synchronize關鍵字，讓線程實現同步。

結論：

在我們使用volatile關鍵字時，需要註意操作是否為原子操作，以免造成線程不安全。

擴展：

其實，對於原子操作，Java已經提供瞭Atomic原子類來解決。其中涉及瞭CAS機制，在不使用Synchronize的情況下，通過比較原值與當前值，不但性能高效，並且也能達到線程安全的目的。

到此這篇關於Synchronize下的volatile關鍵字 的文章就介紹到這瞭,更多相關Synchronize volatile關鍵字 內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：