詳細了解Java並發程式設計三要素-java教程-PHP中文網

本篇文章為大家帶來了關於java的相關知識，其中主要介紹了關於並發程式設計三要素的相關問題，包括了原子性、可見性、有序性以及它們產生的原因和定義等等內容，下面一起來看一下，希望對大家有幫助。

詳細了解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;
  }
}

登入後複製

上面的代码有问题，问题在 ② 操作上：经过优化后的执行路径是这样的：

分配一块内存 M；
将 M 的地址赋值给 instance 变量；
最后在内存 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视频教程》

以上是詳細了解Java並發程式設計三要素的詳細內容。更多資訊請關注PHP中文網其他相關文章！