清醒點

目錄

• Java虛擬執行緒
  • 簡介
  • 執行緒(Thread)簡介
  • 并行(parallel)與并發(concurrent)執行
  • 為什么要使用多執行緒？
    • 多執行緒如何影響系統的效率？
    • 對于唯一詞計算效率又該如何呢？
    • 增加執行緒是否可以解決這個問題呢？
    • 執行緒內部是怎樣作業的？
  • Java內部執行緒實作模式
    • 當前Java執行緒模型有什么問題嗎？
    • 現實世界的例子
  • 虛擬執行緒（Virtual Thread)
  • 虛擬執行緒如何作業
    • Java虛擬執行緒實體
  • 綠色執行緒 VS 虛擬執行緒
  • 總結
  • 參考

Java虛擬執行緒

翻譯自 screencapture-pradeesh-kumar-medium-an-era-of-virtual-threads-java

flowchart LR introduction-->a(why thread)-->b(parallel and concurrent execution)-->c(why threads?)-->d(how does thread work)-->e(java thread model)-->f(virtual thread)-->g(why virtual thread)-->h(comparasion) a-->c d-->f

簡介

“虛擬執行緒”的概念越來越火，很多編程語言都嘗試將其加入到執行緒庫中，Java也不例外，JDK19中便加入了虛擬執行緒（預覽版）JEP425，本文主要深入淺出介紹執行緒的前世今身，以及虛擬執行緒帶來的全新體驗和優勢，最后會對幾種不同的執行緒實作方式進行對比

執行緒(Thread)簡介

一個電腦程式，本質上就是實作特定任務任務的一系列指令，當你加載一個程式時，作業系統加載程式檔案，并將其放置在一個指定區域（地址空間），然后執行它所包含的指令，這時候，它就被作為了一個“行程”，換句話說，一個行程就是一個程式運行在電腦中的實體，

一個執行緒就是行程里的一系列可以獨立運行的指令，通常執行緒在CPU的一個核上運行，一個行程可以擁有多個執行緒，允許多個執行緒同時執行即同時執行多個任務，這樣可以更好的利用CPU資源，提高任務吞吐量，例如，當你加載谷歌瀏覽器，系統便創建了一個谷歌瀏覽器的行程，你可以同事做很多事情，比如說同時下載檔案和瀏覽網頁，因為這些功能運行在不同的執行緒之上，執行緒也可以叫做輕量級行程，因為執行緒之間共享了行程的地址空間，

flowchart LR disk--load-->memory--assign-->process process--include-->thread1 process--include-->thread2 process--include-->thread3 process--include-->thread4

并行(parallel)與并發(concurrent)執行

并行執行：同時執行多個任務，例如，一臺四核的機器，可以每個核執行一個任務，所有的任務是同時執行的，

并發執行：：電腦制造了一種同時執行任務數比CPU核數更多的錯覺，例如，一個四核的電腦，可以執行8個不同的任務，因為你只有四核，所以必須做背景關系切換來執行8個任務，在這里作業系統制造了一種并行執行8個任務的錯覺，然而，實際上只有四個任務可以并行執行，因為只有四核，

并行執行圖例：

flowchart LR core1-->thread1 core2-->thread2 core3-->thread3 core4-->thread4

并發執行圖例：

flowchart LR core1-->a1(thread1)-->a2(thread4)-->a3(thread1)-->a4(thread8)-->a5(thread4) core2-->b1(thread2)-->b2(thread7)-->b3(thread2)-->b4(thread7)-->b5(thread2) core3-->c1(thread3)-->c2(thread5)-->c3(thread10)-->c4(thread3)-->c5(thread5) core4-->d1(thread5)-->d2(thread9)-->d3(thread5)-->d4(thread11)-->d5(thread1)

為什么要使用多執行緒？

首先，讓我們研究一下執行緒是怎樣提高我們的系統效率的，

假如你現在有一臺四核的電腦，你要寫一個兩數之和的程式，同時要求必須執行在12個執行緒中，

代碼如下：

public class SumOfNums {
    static void sum() {
        int a = 1;
        int b = 2;
        int sum = a + b;
        System.out.println(sum);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 12; i++) {
            Thread t = new Thread(SumOfNums::sum);
            t.start();
        }
    }
}

那么有多少執行緒可以并行執行呢？是否12個執行緒都可以并行執行？我們創建了12個執行緒，是否意味著12個執行緒是同時開始執行的？答案是否定的，我們的CPU只有四核，意味著我們并行執行的執行緒數上線就是四核，每個執行緒都必須分配到一個指定的核去執行，通過背景關系切換來完成12個執行緒的并發執行，

那么為什么一個應用會有數百個執行緒？有什么用處？為什么我們不創建恰好等于CPU核數的執行緒？讓我們更深入的研究一下，

任務通常有兩種型別：CPU密集型以及IO密集型，

CPU密集型：任務執行高度依賴CPU，例如算術，邏輯，關聯關系等，這些任務都是CPU密集型；

IO密集型：任務執行高度依賴輸入/輸出操作，例如網路互動，讀取/存盤檔案，這些任務都是IO密集型；

那么我們上面提到的sum任務屬于哪一種呢？我們創建并初始化了兩個變數a和b，將他們求和并輸出到命令列，從始至終都沒有任何的IO操作，數值計算是一個CPU操作，將結果寫到兩一個檔案就是一個IO操作了，

通常來說，一個任務會混合CPU和IO操作，例如讀取一個文本檔案，并計算出其中所有的不同的單詞，然后將結果寫入到另一個文本檔案，在這種情況下，讀取和寫入檔案是一個IO操作，計算不同的單詞是一個CPU操作，

多執行緒如何影響系統的效率？

再思考一下上面的CPU密集型求和代碼，我們使用了12個執行緒并發執行這段代碼，CPU內部切換前后臺執行緒，這樣就可以用4個核心完成12個執行緒的任務，如果還沒有完成一個任務的時候，CPU會切換到另一個執行緒，

12個執行緒真的會提升效率嗎？并非如此，當前的情況下，這里浪費了很多時間在切換背景關系上，對于CPU密集型任務，最好使用和核心數統統的并發執行緒數，以達到最高的效率，

對于唯一詞計算效率又該如何呢？

考慮這樣一種情況，需要讀取20個文本檔案，CPU在讀取檔案時處于空閑狀態，因為檔案讀取發生在硬碟驅動器上，所以只有當檔案背景關系都獲取到了之后，CPU才會開始計算然后將結果寫入到另一個檔案，再寫入程序中，CPU始終處于空閑狀態，等待硬碟驅動器，

也就是說，我們執行的是如下圖所示的單執行緒操作，

flowchart LR a(CPU)--wait-->b(__________IO__________)--hook-->c(CPU calculation)--wait-->d(____________IO__________)--hook-->e(CPU)

如上圖所示，CPU在IO進行的時候都是空閑的，這導致了CPU的核心始終跑不滿100%占用率，

現在，我們考慮一下當我們在4核心CPU上跑4個執行緒，如下圖所示：

flowchart LR a1(CPU)--wait-->b1(__________IO__________)--hook-->c1(CPU calculation)--wait-->d1(____________IO__________)--hook-->e1(CPU) a2(CPU)--wait-->b2(__________IO__________)--hook-->c(CPU calculation)--wait-->d2(____________IO__________)--hook-->e2(CPU) a3(CPU)--wait-->b3(__________IO__________)--hook-->c3(CPU calculation)--wait-->d3(____________IO__________)--hook-->e3(CPU) a4(CPU)--wait-->b4(__________IO__________)--hook-->c4(CPU calculation)--wait-->d4(____________IO__________)--hook-->e4(CPU)

每一個執行緒被賦予了一個指定的核以并發執行，結果就導致了四核出現了與上面單核一樣占用率不滿的問題，IO期間核心依然是空閑的，

增加執行緒是否可以解決這個問題呢？

然我們來看一下如果我們使用八個執行緒會怎樣：

flowchart LR core1-->a1(thread1)-->a2(thread2__)-->a3(_____thread1______)-->a4(__thread2__)-->a5(thread1) core2-->b1(thread3)-->b2(____thread4____)-->b3(thread3)-->b4(thread4)-->b5(thread2) core3-->c1(thread6)-->c2(thread5)-->c3(thread10)-->c4(thread3)-->c5(thread5) core4-->d1(thread5)-->d2(thread6)-->d3(thread5)-->d4(thread8)-->d5(thread1)

首先來看第一個核core1，當thread1進行IO操作時，core1此時是空閑的，然而，當存在多個未執行執行緒時，核心會切換到另一個執行緒開始執行，直到thread1完成了IO操作，這種方式可以最大化利用資源，提升多執行緒時的表現，

所以，在我們的第一個求和任務中，我們使用了比核心更多的執行緒數量沒有獲得效率提升，是因為浪費了過多的資源在背景關系切換上，但是這里，8個執行緒提高了執行效率，我們從中可以學到，選擇執行緒的數量，取決于IO操作頻率和時間占用，IO操作占比越高，就需要越多的執行緒來提高執行效率，

執行緒內部是怎樣作業的？

在我們繼續研究虛擬執行緒前，必須要知道執行緒有哪些分類，以及他們怎么作業，

通常，現在作業系統中有兩種不同的執行緒：核心執行緒以及用戶執行緒

1. 核心執行緒

通常也叫做系統執行緒，核心執行緒通常由作業系統內核來安排管理，每個內核中的執行緒執行緒有一個TCB（Thread Control Block)，其中包括了執行緒的優先級，狀態，以及其它配置資訊，核心執行緒是重量級的，需要系統呼叫來創建，調度，以及同步，

2. 用戶執行緒

用戶執行緒一般使用用戶執行緒庫進行管理和調度，不需要作業系統內核的干涉，內核不能意識到用戶執行緒的變化，每個用戶執行緒代表了一個應用中不同的資料結構，包括執行緒的狀態資訊和配置資訊，用戶執行緒是輕量級的，創建和銷毀比系統執行緒更快，但是，依然會收到一些明確的限制，例如不能夠享受到多處理器或者多核的優秀性能，

簡單講，當一個行程啟動時，會啟動一個默認執行緒，執行應用入口的main方法，隨后，行程會創建自己需要的額外執行緒，用戶執行緒是不能直接執行的，必須映射到一個制定的內核執行緒，然后通過內核執行緒執行執行，用戶執行緒和內核執行緒的映射關系有以下三種：

• M:1：所有的用戶執行緒對應到一個內核執行緒上，通過庫調度器進行調度；
• 1:1：每個用戶執行緒對應一個內核執行緒；
• M:M：所有的用戶執行緒映射到了一個內核執行緒池；

Java內部執行緒實作模式

綠色執行緒（Green Thread）：遠古時期，Java使用綠色執行緒模式，這個模式下，多執行緒的調度和管理有JVM完成，綠色執行緒模式才作用M:1執行緒映射模型，這里就有一個問題，Java不能夠規模化管理這種執行緒，也就無法充分發揮硬體性能，同樣的實作綠色執行緒也是一件非常有挑戰性的事情，因為它需要非常底層的支持才能夠良好運行，隨后java移除了綠色執行緒，轉而使用本地執行緒，這使得Java的執行緒執行比綠色執行緒更慢，

本地執行緒（Native Thread）：從Java1.2開始從綠色執行緒切換到了本地執行緒模式，在作業系統的幫助下，JVM得以控制本地執行緒，本地執行緒的執行效率很高，但是開啟和關閉他們的資源消耗較大，這就是為什么我們現在要使用執行緒池，這個模型遵循著1：1執行緒映射，即一個Java執行緒映射到一個內核執行緒，當一個java執行緒被創建時，相應的一個對應的核心執行緒也會被創建，用來執行執行緒代碼，自此之后，本地執行緒模型的做法就延續到了今天，

當前Java執行緒模型有什么問題嗎？

上面的章節中中，我們知道Java已經使用了本地執行緒模式，讓哦我們看看這個模式有什么問題：

• Java的執行緒庫已經很老舊了；
• 只是對于本地執行緒的一個簡單包裝；
• 本地執行緒的創建和管理資源消耗較大；
• 本地執行緒需要保存他們的呼叫堆疊在記憶體中，大概2MB~20MB的預留空間，如果你有4GB記憶體，如果每個執行緒占用20MB記憶體，那么你就只能創建大概200個執行緒；
• 因為本地執行緒是一種系統資源，加載一個新的本地執行緒大概需要1毫秒；
• 背景關系切換代價昂貴，需要一個到內核的系統呼叫；
• 上面這些強制性的限制會限制執行緒創建的數量，同時會導致性能下降和過度的記憶體消耗，因為我們不能創建更多的執行緒；
• 我們不能通過增加更多的執行緒來增應用規模，因為背景關系切換和記憶體占用的代價高昂；

現實世界的例子

考慮一臺16GB記憶體的網路服務器，對于每個服務請求，都分配一個不同的執行緒，我們假設每個執行緒需要20MB記憶體空間，那么這臺機器可以支持800個執行緒，當前，后端的API一般使用REST/SOAP呼叫方式，例如資料庫操作和API資訊轉發這些IO密集型操作，由此可見，后端服務的主要是IO密集型而不是CPU密集型，

接著假設一下，一個IO操作需要100毫秒，請求執行（IO密集型）需要100毫秒，以及回傳結果也需要100毫秒，同時，當每秒有800個請求時，執行緒數得到了最大容量，

讓我們來計算一下單個請求的CPU占用時間

CPU時間　＝　請求準備時間 +　回傳結果準備時間
		＝　0.1ms +　0.1ms
		= 0.2ms

對于800個請求呢？

800個執行緒的請求時間= 800 * 0.2ms
				= 160ms 

受限于我們的記憶體容量，我們只能創建800個請求，也就導致了我們CPU使用率并不高

PUC使用率=160ms / 1000ms
		= 16%

那么如何才能使CPU的利用率到達90%呢？

16% = 800個執行緒
90% = X個執行緒
X = 4500

但是我們當前因為記憶體的限制不能創建那么多的執行緒，除非我們能突破這個限制，擁有90G記憶體，

90G的記憶體是一個比較離譜的數字，所以說創建本地執行緒很明顯不能充分利用硬體資源，

虛擬執行緒（Virtual Thread)

虛擬執行緒是一個Java執行緒的輕量級實作版本，最早于JDK19中出現，當前仍是預覽狀態，可以通過Jvm配置項開啟，

虛擬執行緒是JVM專案loom的一部分

虛擬執行緒解決了傳遞和維護本地執行緒的瓶頸問題，同時可以用之撰寫高吞吐的并發應用，榨干硬體資源的潛力，

與本地執行緒不同，虛擬執行緒并不有作業系統控制，虛擬執行緒是一個有JVM管理的用戶態執行緒，對比于本地執行緒的高資源占用，每個虛擬執行緒只需要幾個位元組的記憶體空間，這是的它更適合控制管理大量的用戶訪問，或者說處理IO密集型任務，

在創建虛擬執行緒的數量上幾乎沒有限制，甚至可以創建一百萬個，因為虛擬執行緒并不需要來自內核的系統呼叫，

在虛擬執行緒如此輕量化的條件下，執行緒池不再成為必須品，只需要在需要的時候盡情創建虛擬執行緒就好，

虛擬執行緒和傳統的本地執行緒操作完全兼容，例如本地執行緒變數，同步塊，執行緒中斷，等等，

虛擬執行緒如何作業

JVM管理著一個本地執行緒的執行緒池，一個虛擬執行緒想要進行CPU操作時，就把自己關聯到一個池中本地執行緒的佇列中，當虛擬執行緒中的CPU操作執行完畢后，JVM會自動解除關聯并掛起該虛擬執行緒，同時切換到并執行另一個虛擬執行緒，這就是為什么我們可以創建很多的虛擬執行緒，并且他們是如此的輕量級，

JVM使用M:N來完成虛擬執行緒與本地執行緒的映射，

Java虛擬執行緒實體

1. 在現存的執行緒使用新的ofVirtual()工廠方法：

for (int i = 0; i < 5; i++) {
    Thread vThread = Thread.ofVirtual().start(() -> System.out.println("Hellow World!!!"));
}

2. 使用新的Executors工廠的newVirtualThreadExecutor()方法：

public static void main(String[] args) throws InterruptedException {
    var executor = Executors.newVirtualThreadPerTaskExecutor();
    for (int i = 0; i < 16; i++) {
        executor.submit(()-> System.out.println("Hello World!!!"));
    }
    executor.awaitTermination(1, TimeUnit.SECONDS);
    System.out.println("Finished");
}

綠色執行緒 VS 虛擬執行緒

執行緒型別	簡介	映射
綠色執行緒	在一個系統執行緒上運行多個綠色執行緒	M:1
平臺執行緒（Java當前使用）	系統執行緒的包裝	1:1
虛擬執行緒	在多個系統執行緒中運行多個虛擬執行緒	M:N(M>N)

總結

總而言之，虛擬執行緒的新特性先對于傳統多執行緒擁有很多優勢，通過在用戶空間提供的輕量化并發模型，虛擬執行緒使得撰寫并發程式更容易，使得大規模的執行緒并發成為可能，

參考

[1] screencapture-pradeesh-kumar-medium-an-era-of-virtual-threads-java

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/554324.html

標籤：Java

上一篇：41基于java的倉庫管理系統設計與實作

下一篇：返回列表