Java并發編程的三要素是什么

本篇內容介紹了“Java并發編程的三要素是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

1 原子性

1.1 原子性的定義

原子性指的是一個或者多個操作，要么全部執行并且在執行的過程中不被其他操作打斷，要么就全部都不執行。

1.2 原子性問題原因

線程切換是產生原子性問題的原因，線程切換是為了提高 CPU 的利用率。

以 count ++ 為例，至少需要三條 CPU 指令：

• 指令 1：首先，需要把變量 count 從內存加載到 CPU 的寄存器；

• 指令 2：之后，在寄存器中執行 +1 操作；

• 指令 3：最后，將結果寫入內存（緩存機制導致可能寫入的是 CPU 緩存而不是內存）。

我們假設 count=0，如果線程 A 在指令 1 執行完后做線程切換，線程 A 和線程 B 按照下圖的序列執行，那么我們會發現兩個線程都執行了 count+=1 的操作，但是得到的結果不是我們期望的 2，而是 1。

1.3 原子性操作

多線程環境下中，Java 只保證了基本數據類型的變量和賦值操作才是原子性的（ 注：在32位的JDK環境下，對64位數據的讀取不是原子性操作*，如long、double ）

1.4 原子性問題如何解決

如果我們能夠保證對共享變量的修改是互斥的，那么，無論是單核 CPU 還是多核 CPU，就都能保證原子性了。加鎖可以解決原子性問題，如使用 synchronized、lock 。

2 可見性

2.1 可見性定義

可見性指多個線程操作一個共享變量時，其中一個線程對變量進行修改后，其他線程可以立即看到修改的結果。

2.2 可見性問題原因

CPU 緩存與內存的數據一致性是導致可見性問題的原因，CPU 緩存是為了提高 CPU 的效率。

2.3 可見性問題解決

產生可見性問題的原因是 CPU 緩存，那我們禁用 CPU 緩存就可以了。

• volatile 字段能禁用 CPU 緩存，解決可見性問題。

• synchronized 和鎖都可以保證可見性。

2.4 可見性規則是什么

可見性規則就是 Happens-Before 規則 。

Happens-Before 規則：

• 簡單來說就是： 前面一個操作的結果對后續操作是可見的。

• Happens-Before 約束了編譯器的優化行為，雖允許編譯器優化，但是要求編譯器優化后一定遵守 Happens-Before 規則。

2.5 Happens-Before 規則

• 程序的順序性規則

在一個線程中，按照程序順序，前面的操作 Happens-Before 于后續的任意操作。

class Example {
  public void test() {
    int x = 42;   ①
    int y = 20;   ②
  }
 
}

①  Happens-Before ② 。

• volatile 變量規則

對一個 volatile 變量的寫操作， Happens-Before 于后續對這個 volatile 變量的讀操作。

• 傳遞性規則

如果 A Happens-Before B，且 B Happens-Before C，那么 A Happens-Before C。

class Example {
  int x = 0;
  volatile int y = 0;
  public void writer() {
    x = 42;      ①
    y = 1;       ②
  }
  public void reader() {
    if (y == 1) {  ③
      // 這里x會是多少呢？
    }
  }
}

• ① Happens-Before ② ，滿足規則1-順序性規則。

• ② Happens-Before ③，滿足規則2-volatile 變量規則。

• ① Happens-Before ③，滿足規則3-傳遞性規則。如果 y == 1，則 x = 42；

• 管程中鎖的規則

對一個鎖的解鎖 Happens-Before 于后續對這個鎖的加鎖。

管程是一種通用的同步原語，在 Java 中指的就是 synchronized，synchronized 是 Java 里對管程的實現。

synchronized (this) { //此處自動加鎖
  // x是共享變量,初始值=10
  if (this.x < 12) {
    this.x = 12; 
  }  
} //此處自動解鎖

假設 x 的初始值是 10，線程 A 執行完代碼塊后 x 的值會變成 12（執行完自動釋放鎖）;

線程 B 進入代碼塊時，能夠看到線程 A 對 x 的寫操作，也就是線程 B 能夠看到 x==12。

• 線程 start() 規則

它是指主線程 A 啟動子線程 B 后，子線程 B 能夠看到主線程在啟動子線程 B 前的操作。

• 線程 join() 規則

它是指主線程 A 等待子線程 B 完成（主線程 A 通過調用子線程 B 的 join() 方法實現），當子線程 B 完成后（主線程 A 中 join() 方法返回），主線程能夠看到子線程的操作。當然所謂的“看到”，指的是對共享變量的操作。

3 有序性

3.1 有序性的定義

有序性，即程序的執行順序按照代碼的先后順序來執行。

3.2 有序性問題原因

編譯器為了優化性能，有時候會改變程序中語句的先后順序。

例如：“a=6；b=7；”編譯器優化后可能變成“b=7；a=6；”，在這個例子中，編譯器調整了語句的順序，但是不影響程序的最終結果。

以雙重檢查代碼為例：

public class Singleton {
  static Singleton instance;
  static Singleton getInstance(){
    if (instance == null) {    ①
      synchronized(Singleton.class) {
        if (instance == null)
          instance = new Singleton();  ②
        }
    }
    return instance;
  }
}

上面的代碼有問題，問題在 ② 操作上：經過優化后的執行路徑是這樣的：

1. 分配一塊內存 M；

2. 將 M 的地址賦值給 instance 變量；

3. 最后在內存 M 上初始化 Singleton 對象。

優化后會導致什么問題呢？我們假設線程 A 先執行 getInstance() 方法，當執行完 ① 時恰好發生了線程切換，切換到了線程 B 上；如果此時線程 B 也執行 getInstance() 方法，那么線程 B 在執行第一個判斷時會發現 instance != null ，所以直接返回 instance，而此時的 instance 是沒有初始化過的，如果我們這個時候訪問 instance 的成員變量就可能觸發空指針異常。

如何解決雙重檢查問題？變量用 volatile 來修飾，禁止指令重排序。

public class Singleton {
  static volatile Singleton instance;
  static Singleton getInstance(){
    if (instance == null) {    ①
      synchronized(Singleton.class) {
        if (instance == null)
          instance = new Singleton();  ②
        }
    }
    return instance;
  }
}

“Java并發編程的三要素是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！