Java并發(fā)編程的三要素是什么

本篇內(nèi)容介紹了“Java并發(fā)編程的三要素是什么”的有關(guān)知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領(lǐng)大家學(xué)習(xí)一下如何處理這些情況吧！希望大家仔細(xì)閱讀，能夠?qū)W有所成！

1 原子性

1.1 原子性的定義

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

1.2 原子性問題原因

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

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

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

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

• 指令 3：最后，將結(jié)果寫入內(nèi)存（緩存機(jī)制導(dǎo)致可能寫入的是 CPU 緩存而不是內(nèi)存）。

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

1.3 原子性操作

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

1.4 原子性問題如何解決

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

2 可見性

2.1 可見性定義

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

2.2 可見性問題原因

CPU 緩存與內(nèi)存的數(shù)據(jù)一致性是導(dǎo)致可見性問題的原因，CPU 緩存是為了提高 CPU 的效率。

2.3 可見性問題解決

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

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

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

2.4 可見性規(guī)則是什么

可見性規(guī)則就是 Happens-Before 規(guī)則 。

Happens-Before 規(guī)則：

• 簡單來說就是： 前面一個操作的結(jié)果對后續(xù)操作是可見的。

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

2.5 Happens-Before 規(guī)則

• 程序的順序性規(guī)則

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

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

①  Happens-Before ② 。

• volatile 變量規(guī)則

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

• 傳遞性規(guī)則

如果 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 ② ，滿足規(guī)則1-順序性規(guī)則。

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

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

• 管程中鎖的規(guī)則

對一個鎖的解鎖 Happens-Before 于后續(xù)對這個鎖的加鎖。

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

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

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

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

• 線程 start() 規(guī)則

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

• 線程 join() 規(guī)則

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

3 有序性

3.1 有序性的定義

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

3.2 有序性問題原因

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

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

以雙重檢查代碼為例：

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

上面的代碼有問題，問題在 ② 操作上：經(jīng)過優(yōu)化后的執(zhí)行路徑是這樣的：

1. 分配一塊內(nèi)存 M；

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

3. 最后在內(nèi)存 M 上初始化 Singleton 對象。

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

如何解決雙重檢查問題？變量用 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并發(fā)編程的三要素是什么”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識可以關(guān)注億速云網(wǎng)站，小編將為大家輸出更多高質(zhì)量的實用文章！