一夜搞懂 | Java 記憶體模型與執行緒

• 2020 年 4 月 9 日
• 筆記

前言

本文已經收錄到我的 Github 個人部落格，歡迎大佬們光臨寒舍：

我的 GIthub 部落格

學習導圖

一.為什麼要學習記憶體模型與執行緒？

並發處理的廣泛應用是 Amdah1 定律代替摩爾定律成為電腦性能發展源動力的根本原因，也是人類壓制電腦運算能力的最有力武器

執行緒通訊是指執行緒之間以何種機制來交換資訊。在命令式編程中，執行緒之間的通訊機制有兩種：共享記憶體和消息傳遞。

執行緒同步是指程式用於控制不同執行緒之間操作發生相對順序的機制。

Java 的並發採用的是共享記憶體模型，Java 執行緒之間的通訊總是隱式進行，整個通訊過程對程式設計師完全透明。如果你想設計表現良好的並發程式，理解 Java 記憶體模型是非常重要的。Java 記憶體模型規定了如何和何時可以看到由其他執行緒修改過後的共享變數的值，以及在必須時如何同步的訪問共享變數。

二.核心知識點歸納

2.1 概述

Q1：多任務處理的必要性

• 充分利用電腦處理器的能力，避免處理器在磁碟 I/O、網路通訊或資料庫訪問時總是處於等待其他資源的狀態
• 便於一個服務端同時對多個客戶端提供服務

通過指標 TPS（Transactions Per Second）可衡量一個服務性能的高低好壞，它表示每秒服務端平均能響應的請求總數，進而體現出程式的並發能力

Q2：硬體的效率與一致性

為了更好的理解 Java 記憶體模型，先理解物理電腦中的並發問題，兩者有很高的可比性

為了平衡記憶體交互速度與處理器的運算速度之間幾個數量級的差距，引入一層高速快取（Cache）來作為記憶體與處理器之間的緩衝：

• 將運算需要使用到的數據複製到快取中，讓運算能快速進行
• 當運算結束後再從快取同步回記憶體之中，而無須讓處理器等待緩慢的記憶體讀寫

• 出現問題：引入高速快取雖解決了處理器與記憶體速度之間的矛盾，但是其引入了一個新的問題——快取一致性
• 解決辦法：需要各個處理器訪問快取時都遵循一些協議，在讀寫時要根據協議來進行操作

記憶體模型可以理解為：在特定的操作協議下，對特定的記憶體或高速快取進行讀寫訪問的過程抽象

2.2 Java 記憶體模型

之前筆者在 進階之路 | 奇妙的Thread之旅中簡要介紹過 Java 記憶體模型，相信看過的讀者都有一些印象

2.2.1 設計目的

屏蔽掉各種硬體和作業系統的記憶體訪問差異，實現 Java 程式在各種平台下都能達到一致的記憶體訪問效果

2.2.2 設計方法

通過定義程式中各個變數的訪問規則，即在虛擬機中將變數存儲到記憶體和從記憶體中取出變數這樣的底層細節

注意：這裡的變數與 Java 中說的變數不同，而指的是實例欄位、靜態欄位和構成數組對象的元素，但不包括局部變數與方法參數（其存放於局部變數表中，而局部變數表在 JVM 棧中），因為後者是執行緒私有的，不會被共享，自然就不會存在競爭問題。

2.2.3 模型結構

• 主記憶體：所有變數的存儲位置。直接對應於物理硬體的記憶體

注意：這裡的主記憶體、工作記憶體與 一文洞悉JVM記憶體管理機制 說的 Java 記憶體區域中的 Java 堆、棧、方法區等並不是同一個層次的記憶體劃分

• 工作記憶體：每條執行緒還有自己的工作記憶體，用於保存被該執行緒使用到的變數的主記憶體副本拷貝。為了獲取更好的運行速度，虛擬機可能會讓工作記憶體優先存儲於暫存器和高速快取中

注意：

• 執行緒對變數的所有操作都必須在工作記憶體中進行，而不能直接讀寫主記憶體中的變數
• 不同的執行緒之間也無法直接訪問對方工作記憶體中的變數，執行緒間變數值的傳遞必須通過主記憶體來完成

• 交互協議：用於規定一個變數如何從主記憶體拷貝到工作記憶體、如何從工作記憶體同步回主記憶體之類的實現細節。

  共有 8 種操作：

1. 作用於主記憶體變數：

• 鎖定 lock ：把變數標識為一條執行緒獨佔的狀態
• 解鎖 unlock ：把處於鎖定狀態的變數釋放出來
• 寫入 write ：把 store 操作從工作記憶體中得到的變數的值放入主記憶體的變數中
• 讀取 read ：把變數的值從主記憶體傳輸到執行緒的工作記憶體中，以便隨後的 load 動作使用

​ 2.用於工作記憶體變數：

• 賦值 assign ：把從執行引擎接收到的值賦給工作記憶體的變數
• 使用 use ：把工作記憶體中一個變數的值傳遞給執行引擎
• 存儲 store ：把工作記憶體中變數的值傳送到主記憶體中，以便隨後的 write 操作使用
• 寫入 write ：把 store 操作從工作記憶體中得到的變數的值放入主記憶體的變數中

結論：注意是順序非連續

• 如果要把變數從主記憶體複製到工作記憶體，那就要順序地執行 read 和 load
• 如果要把變數從工作記憶體同步回主記憶體，就要順序地執行 store 和 write

2.2.4 確保並發操作安全的原則

A1：執行八種基本操作的時候，必須滿足如下規則：

• 不允許 read 和 load、store 和 write 操作之一單獨出現，即不允許一個變數從主記憶體讀取了但工作記憶體不接受，或者從工作記憶體發起回寫了但主記憶體不接受的情況出現

可以簡單理解為不能拒絕別人給的東西

• 不允許一個執行緒丟棄它的最近的 assign 操作，即變數在工作記憶體中改變了之後必須把該變化同步回主記憶體
• 不允許一個執行緒無原因地，即沒有發生過任何 assign 操作，就把數據從執行緒的工作記憶體同步回主記憶體中
• 一個新的變數只能在主記憶體中 「誕生」，不允許在工作記憶體中直接使用一個未被初始化（load 或 assign）的變數，即對一個變數實施 use、store 操作之前必須先執行過了 assign 和 load 操作
• 如果對一個變數執行 lock 操作，那將會清空工作記憶體中此變數的值，在執行引擎使用這個變數前，需要重新執行 load 或 assign 操作初始化變數的值

下文的 volatile底層就是用到了 lock 來實現可見性

• 如果一個變數事先沒有被 lock 操作鎖定，那就不允許對它執行 unlock 操作，也不允許去 unlock 一個被其他執行緒鎖定住的變數
• 對一個變數執行 unlock 操作之前，必須先把此變數同步回主記憶體中

可見這麼多規則非常繁瑣，實踐也麻煩，下面再介紹一個等效判斷原則 -- 先行發生原則

A2：先行發生原則：

是 Java 記憶體模型中定義的兩項操作之間的偏序關係。

下面例舉一些 「天然的」 先行發生關係，無須任何同步器協助就已經存在，可以在編碼中直接使用

• 程式次序規則：在一個執行緒內，按照控制流順序，書寫在前面的操作先行發生於書寫在後面的操作
• 管程鎖定規則：一個 unlock 操作先行發生於後面對同一個鎖的 lock 操作
• volatile 變數規則：對一個 volatile 變數的寫操作先行發生於後面對這個變數的讀操作
• 執行緒啟動規則：Thread 的 start() 先行發生於此執行緒的每一個動作
• 執行緒終止規則：執行緒中的所有操作都先行發生於對此執行緒的終止檢測。可通過 Thread.join() 結束、Thread.isAlive() 的返回值等手段檢測到執行緒已經終止執行
• 執行緒中斷規則：對執行緒 interrupt() 的調用先行發生於被中斷執行緒的程式碼檢測到中斷事件的發生。可通過 Thread.isInterrupted() 檢測到是否有中斷髮生
• 對象終結規則：一個對象的初始化完成先行發生於它的 finalize() 的開始
• 傳遞性：如果操作 A 先行發生於操作 B，操作 B 先行發生於操作 C，那麼操作 A 一定先行發生於操作 C

2.2.5 保證原子性、可見性和有序性的措施

• 原子性：一個操作要麼都執行要麼都不執行

• 可直接保證的原子性變數操作有：read、load、assign、use、store 和 write，因此可認為基本數據類型的訪問讀寫是具備原子性的

• 若需要保證更大範圍的原子性，可通過更高層次的位元組碼指令 monitorenter 和 monitorexit 來隱式地使用 lock 和 unlock 這兩個操作，反映到 Java 程式碼中就是同步程式碼塊 synchronized 關鍵字

• 可見性：當一個執行緒修改了共享變數的值，其他執行緒能夠立即得知這個修改

• 通過在變數修改後將新值同步回主記憶體，在變數讀取前從主記憶體刷新變數值這種依賴主記憶體作為傳遞媒介的方式來實現
• 提供三個關鍵字保證可見性：
  1. volatile 能保證新值能立即同步到主記憶體，且每次使用前立即從主記憶體刷新
  2. synchronized 對一個變數執行 unlock 操作之前可以先把此變數同步回主記憶體中
  3. 被 final 修飾的欄位在構造器中一旦初始化完成且構造器沒有把 this 的引用傳遞出去，就可以在其他執行緒中就能看見 final 欄位的值

• 有序性：程式程式碼按照指令順序執行

• 如果在本執行緒內觀察，所有的操作都是有序的，指 「執行緒內表現為串列的語義」；
• 如果在一個執行緒中觀察另一個執行緒，所有的操作都是無序的，指 「指令重排序」 現象和 「工作記憶體與主記憶體同步延遲」 現象
• 提供兩個關鍵字保證有序性：
  1. volatile 本身就包含了禁止指令重排序的語義
  2. synchronized 保證一個變數在同一個時刻只允許一條執行緒對其進行 lock 操作，使得持有同一個鎖的兩個同步塊只能串列地進入

想詳細了解 volatile 的讀者，可以看下筆者之前寫的文章：進階之路 | 奇妙的 Thread 之旅

2.3 Java 與執行緒

2.3.1 執行緒實現的三種方式

1.使用內核執行緒

英文： Kernel-Level Thread ，簡稱：KLT

• 定義：由作業系統內核支援的執行緒
• 原理：由內核來完成執行緒切換，內核通過操縱調度器（Scheduler）對執行緒進行調度，並負責將執行緒的任務映射到各個處理器上。每個內核執行緒可以視為內核的一個分身， 這樣作業系統就有能力同時處理多件事情
• 多執行緒內核：支援多執行緒的內核
• 輕量級進程（Light Weight Process,簡稱：LWP）：內核執行緒的一種高級介面

• 優點：每個輕量級進程都由一個內核執行緒支援，因此每個都成為一個獨立的調度單元，即使有一個輕量級進程在系統調用中阻塞，也不會影響整個進程繼續工作
• 缺點：
  1. 由於基於內核執行緒實現，所以各種執行緒操作（創建、析構及同步）都需要進行系統調用，代價相對較高，需要在用戶態和內核態中來回切換
  2. 一個系統支援輕量級進程的數量是有限的
• 一對一執行緒模型：輕量級進程與內核執行緒之間 1：1 的關係，如圖所示

2.使用用戶執行緒

英文： User Thread ，簡稱：UT

• 定義：

• 廣義上認為一個執行緒不是內核執行緒就是用戶執行緒
• 狹義上認為用戶執行緒指的是完全建立在用戶空間的執行緒庫上，而系統內核不能感知執行緒存在的實現

• 優點：由於用戶執行緒的建立、同步、銷毀和調度完全在用戶態中完成，不需要內核的幫助，甚至可以不需要切換到內核態，所以操作非常快速且低消耗的，且可以支援規模更大的執行緒數量
• 缺點：由於沒有系統內核的支援，所有的執行緒操作都需要用戶程式自己處理，執行緒的創建、切換和調度都是需要考慮的問題，實現較複雜
• 一對多的執行緒模型進程：進程與用戶執行緒之間 1：N 的關係，如圖所示

3.混合

• 定義：既存在用戶執行緒，也存在輕量級進程

• 優點：

• 用戶執行緒完全建立在用戶空間中，因此用戶執行緒的創建、切換、析構等操作依然廉價，並且可以支援大規模的用戶執行緒並發
• 作業系統提供支援的輕量級進程作為用戶執行緒和內核執行緒之間的橋樑，可以使用內核提供的執行緒調度功能及處理器映射，且用戶執行緒的系統調用要通過輕量級執行緒來完成，大大降低了整個進程被完全阻塞的風險

• 多對多的執行緒模型：用戶執行緒與輕量級進程的數量比不定，即用戶執行緒與輕量級進程之間 N：M 的關係，如圖所示

Q： Java 執行緒的實現是選擇哪一種呢？

A：答案是不確定的。作業系統支援怎樣的執行緒模型，在很大程度上決定了 JVM 的執行緒是怎樣映射的。執行緒模型只對執行緒的並發規模和操作成本產生影響，而對 Java 程式的編碼和運行過程來說，這些差異都是透明的。

2.3.2 執行緒調度的兩種方式

執行緒調度：指系統為執行緒分配處理器使用權的過程

1.協同式執行緒調度

• 由執行緒本身來控制執行緒的執行時間。執行緒把自己的工作執行完後，要主動通知系統切換到另外一個執行緒上
• 好處：

• 實現簡單
• 切換操作自己可知，不存在執行緒同步的問題

• 壞處：執行緒執行時間不可控，假如一個執行緒編寫有問題一直不告知系統進行執行緒切換，那麼程式就會一直被阻塞

2.搶佔式執行緒調度

• 由系統來分配每個執行緒的執行時間
• 好處：執行緒執行時間是系統可控的，不存在一個執行緒導致整個進程阻塞的問題
• 可以通過設置執行緒優先順序，優先順序越高的執行緒越容易被系統選擇執行

但是執行緒優先順序並不是太靠譜，一方面因為 Java 的執行緒是通過映射到系統的原生執行緒上來實現的，所以執行緒調度最終還是取決於作業系統，在一些平台上不同的優先順序實際會變得相同；另一方面優先順序可能會被系統自行改變。

2.3.3 執行緒的六種狀態

在任意一個時間點，一個執行緒只能有且只有其中的一種狀態：

• 新建 New ：執行緒創建後尚未啟動

• 運行 Runable：包括正在執行（Running）和等待著 CPU 為它分配執行時間（Ready）兩種

• 無限期等待 Waiting：該執行緒不會被分配 CPU 執行時間，要等待被其他執行緒顯式地喚醒。

  以下方法會讓執行緒陷入無限期等待狀態：

• 沒有設置 Timeout 參數的 Object.wait()

• 沒有設置 Timeout 參數的 Thread.join()

• LockSupport.park()

  (PS：想詳細了解它的可以看下這篇文章：Java 多執行緒學習（7）聊聊 LockSupport.park () 和 LockSupport.unpark ())

• 限期等待 Timed Waiting：該執行緒不會被分配 CPU 執行時間，但在一定時間後會被系統自動喚醒。以下方法會讓執行緒進入限期等待狀態：

• Thread.sleep()
• 設置了 Timeout 參數的 Object.wait()
• 設置了 Timeout 參數的 Thread.join()
• LockSupport.parkNanos()
• LockSupport.parkUntil()

• 阻塞 Blocked：執行緒被阻塞

注意區別阻塞和等待：

• 阻塞狀態：在等待獲取到一個排他鎖，在另外一個執行緒放棄這個鎖的時候發生；
• 等待狀態：在等待一段時間或者喚醒動作的發生，在程式等待進入同步區域的時候發生。

• 結束 Terminated：執行緒已經結束執行

三.碎碎念

恭喜你！已經看完了前面的文章，相信你對 Java 記憶體模型與執行緒已經有一定深度的了解！你可以稍微放鬆獎勵自己一下，可以睡一個美美的覺，明天起來繼續沖沖沖！！！

PS：原本《深入理解Java虛擬機》第3版中還提及了協程，但是我還沒學過協程的基本用法，這時候給大家講解感覺有點打腫臉充胖子的感覺 hhh，明天《第一行程式碼-第三版》也要到了，待我看完《第一行程式碼》再補充協程的內容吧 hhhh

如果文章對您有一點幫助的話，希望您能點一下贊，您的點贊，是我前進的動力

本文參考鏈接：

• 《深入理解Java虛擬機》第3版
• 理解Java記憶體模型
• Java 多執行緒學習（7）聊聊 LockSupport.park () 和 LockSupport.unpark ()
• 要點提煉 | 理解 JVM 之記憶體模型 & 執行緒
• 啃碎並發（九）：記憶體模型之基礎概述