一文讀懂JAVA多線程

時間 2020-07-21

標籤一文讀懂 java 多線程欄目 Java 简体版

原文原文鏈接

一文讀懂JAVA多線程

背景淵源

摩爾定律

提到多線程好多書上都會提到摩爾定律,它是由英特爾創始人之一Gordon Moore提出來的。其內容爲：當價格不變時，集成電路上可容納的元器件的數目，約每隔18-24個月便會增長一倍，性能也將提高一倍。換言之，每一美圓所能買到的電腦性能，將每隔18-24個月翻一倍以上。這必定律揭示了信息技術進步的速度。java

但是從2003年開始CPU主頻已經再也不翻倍，而是採用多核，而不是更快的主頻。摩爾定律失效。那主頻再也不提升,核數增長的狀況下要想讓程序更快就要用到並行或併發編程。數據庫

並行與併發

若是CPU主頻增長程序不用作任何改動就能變快。但核多的話程序不作改動不必定會變快。編程

CPU廠商生產更多的核的CPU是能夠的，一百多核也是沒有問題的，可是軟件尚未準備好，不能更好的利用，因此沒有生產太多核的CPU。隨着多核時代的來臨，軟件開發愈來愈關注並行編程的領域。但要寫一個真正並行的程序並不容易。設計模式

並行和併發的目標都是最大化CPU的使用率，併發能夠認爲是一種程序的邏輯結構的設計模式。能夠用併發的設計方式去設計模型，而後運行在一個單核的系統上。能夠將這種模型不加修改的運行在多核系統上，實現真正的並行，並行是程序執行的一種屬性真正的同時執行，其重點的是充分利用CPU的多個核心。數組

多線程開發的時候會有一些問題，好比安全性問題，一致性問題等，重排序問題，由於這些問題而後你們在寫代碼的時候會加鎖等等。這些基礎概念你們都懂，本文再也不描述。本文主要分享形成這些問題的緣由和JAVA解決這些問題的底層邏輯。緩存

多線程

計算機存儲體系

要想明白數據一致性問題，要先縷下計算機存儲結構，從本地磁盤到主存到CPU緩存，也就是從硬盤到內存，到CPU。通常對應的程序的操做就是從數據庫查數據到內存而後到CPU進行計算。這個描述有點粗，下邊畫個圖。安全

業內畫這個圖通常都是畫的金字塔型狀，爲了證實是我本身畫的我畫個長方型的（其實我不會畫金字塔）。多線程

CPU多個核心和內存之間爲了保證內部數據一致性還有一個緩存一致性協議（MESI），MESI其實就是指令狀態中的首字母。M（Modified）修改，E（Exclusive）獨享、互斥，S（Shared）共享，I（Invalid）無效。而後再看下邊這個圖。併發

太細的狀態流轉就不做描述了，扯這麼多主要是爲了說明白爲何會有數據一致性問題，就是由於有這麼多級的緩存，CPU的運行並非直接操做內存而是先把內存裏邊的數據讀到緩存，而內存的讀和寫操做的時候就會形成不一致的問題。解決一致性問題怎麼辦呢，兩個思路。app

鎖住總線，操做時鎖住總線，這樣效率很是低，因此考慮第二個思路。
緩存一致性，每操做一次通知（一致性協議MESI），（但多線程的時候仍是會有問題，後文講）

JAVA內存模型

上邊稍微扯了一下存儲體系是爲了在這裏寫一下JAVA內存模型。

Java虛擬機規範中試圖定義一種Java內存模型（java Memory Model) 來屏蔽掉各類硬件和操做系統的內存訪問差別，以實現讓Java程序在各類平臺下都能達到一致的內存訪問效果。

內存模型是內存和線程之間的交互、規則。與編譯器有關，有併發有關，與處理器有關。

Java內存模型的主要目標是定義程序中各個變量的訪問規則，即在虛擬機中將變量存儲到內存和從內存中取出變量這樣的底層細節。此處的變量與Java編程中所說的變量有所區別，它包括了實例字段、靜態字段和構成數組對象的元素，但不包括局部變量與方法參數，由於後者是線程私有的，不會被共享，天然就不會存在競爭問題。爲了得到較好的執行效能，Java內存模型並無限制執行引擎使用處理器特定寄存器或緩存來和主內存進行交互，也沒有限制即時編譯器進行調整代碼執行順序這類優化措施。

Java內存模型規定了全部的變量都存儲在主內存中。每條線程還有本身的工做內存，線程的工做內存中保存了該線程使用到的變量的主內存副本拷貝，線程對變量的全部操做（讀取，賦值等）都必需在工做內存中進行，而不能直接讀寫主內存中的變量。不一樣的線程之間也沒法直接訪問對方工做內存中的變量，線程間變量值的傳遞均須要經過主內存來完成。

這裏所說的主內存、工做內存和Java內存區域中的Java堆、棧、方法區等並非同一個層次的內存劃分，這二者基本上是沒有關係的。 若是二者必定要勉強對應起來，那從變量、主內存、工做內存的定義來看，主內存對應Java堆中的對象實例數據部分，而工做內存則對應於虛擬機棧中的部分區域。從更底層次上說，主內存就是直接對應於物理硬件的內存，而爲了獲取更好的運行速度，虛擬機可能會讓工做內存優先存儲於寄存器和高速緩存中，由於程序運行時主要訪問讀寫的是工做內存。

前邊說的都是和內存有關的內容，其實多線程有關係的還有指令重排序，指令重排序也會形成在多線程訪問下結束和想的不同的狀況。大段的介紹就不寫了要不篇幅太長了（JVM那裏書裏邊有）。主要就是在CPU執行指令的時候會進行執行順序的優化。畫個圖看一下吧。

具體理論後文再寫先來點乾貨，直接上代碼，一看就明白。

public class HappendBeforeTest {
    int a = 0;
    int b = 0;
    public static void main(String[] args) {
        HappendBeforeTest test = new HappendBeforeTest();
        Thread threada = new Thread() {
            @Override
            public void run() {
                test.a = 1;
                System.out.println("b=" + test.b);
            }
        };
        Thread threadb = new Thread() {
            @Override
            public void run() {
                test.b = 1;
                System.out.println("a=" + test.a);
            }
        };
        threada.start();
        threadb.start();
    }
}

猜猜有可能輸出什麼？多選

A：ａ＝０，ｂ＝１
B：ａ＝１，ｂ＝０
C：ａ＝０，ｂ＝０
D：ａ＝１，ｂ＝１

上邊這段代碼不太好調，而後我稍微改造了一下。

public class HappendBeforeTest {
    static int a = 0;
    static int b = 0;
    static int x = 0;
    static int y = 0;
    public static void shortWait(long interval) {
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        }
        while (start + interval >= end);
    }
    public static void main(String[] args) throws InterruptedException {
        for (; ; ) {
            Thread threada = new Thread() {
                @Override
                public void run() {
                    a = 1;
                    x = b;
                }
            };
            Thread threadb = new Thread() {
                @Override
                public void run() {
                    b = 1;
                    y = a;
                }
            };
            Thread starta = new Thread() {
                @Override
                public void run() {
                    // 因爲線程threada先啓動
                    //下面這句話讓它等一等線程startb
                    shortWait(100);
                    threada.start();
                }
            };
            Thread startb = new Thread() {
                @Override
                public void run() {
                    threadb.start();
                }
            };
            starta.start();
            startb.start();
            starta.join();
            startb.join();
            threada.join();
            threadb.join();
            a = 0;
            b = 0;
            System.out.print("x=" + x);
            System.out.print("y=" + y);
            if (x == 0 && y == 0) {
                break;
            }
            x = 0;
            y = 0;
            System.out.println();
        }
    }
}

這段代碼，a和b初始值爲0，而後兩個線程同時啓動分別設置a=1,x=b和b=1,y=a。這個代碼裏邊的starta和startb線程徹底是爲了讓threada 和threadb 兩個線程儘可能同時啓動而加的，裏邊只是分別調用了threada 和threadb 兩個線程。而後無限循環只要x和y 不一樣時等於0就初始化全部值繼續循環，直到x和y都是0的時候break。你猜猜會不會break。

結果看截圖

由於我沒有記錄循環次數，不知道循環了幾回，而後觸發了條件break了。從代碼上看，在輸出A以前必然會把B設置成1，在輸出B以前必然會把A設置爲1。那爲何會出現同時是零的狀況呢。這就頗有多是指令被重排序了。

指令重排序簡單了說是就兩行以上不相干的代碼在執行的時候有可能先執行的不是第一條。也就是執行順序會被優化。

如何判斷你寫的代碼執行順序會不會被優化，要看代碼之間有沒有Happens-before關係。Happens-before就是不無需任何干涉就能夠保證有有序執行，因爲篇幅限制Happens-before就不在這裏多作介紹。

下面簡單介紹一下java裏邊的一個關鍵字volatile。volatile簡單來講就是來解決重排序問題的。對一個volatile變量的寫，必定happen-before後續對它的讀。也就是你在寫代碼的時候不但願你的代碼被重排序就使用volatile關鍵字。volatile還解決了內存可見性問題，在執行執行的時候一共有8條指令lock(鎖定)、read(讀取)、load(載入)、use(使用)、assign(賦值)、store(存儲)、write(寫入)、unlock(解鎖)（篇幅限制具體指令內容自行查詢，看下圖大概有個瞭解）。

volatile主要是對其中4條指令作了處理。以下圖

也就是把 load和use關聯執行，把assign和store關聯執行。衆所周知有load必需有read如今load又和use關聯也就是要在緩存中要use的時候就必需要load要load就必須要read。通俗講就是要use(使用)一個變量的時候必需load(載入），要載入的時候必需從主內存read(讀取）這樣就解決了讀的可見性。下面看寫操做它是把assign和store作了關聯，也就是在assign(賦值)後必需store(存儲)。store(存儲）後write(寫入）。也就是作到了給一個變量賦值的時候一串關聯指令直接把變量值寫到主內存。就這樣經過用的時候直接從主內存取，在賦值到直接寫回主內存作到了內存可見性。

無鎖編程

我在網上看到大部分寫多線程的時候都會寫到鎖，AQS和線程池。因爲網文太多本文就很少作介紹。下面簡單寫一寫CAS。

CAS是一個比較魔性的操做，用的好可讓你的代碼更優雅更高效。它就是無鎖編程的核心。

CAS書上是這麼介紹的：「CAS即Compare and Swap，是JDK提供的非阻塞原子性操做，它經過硬件保證了比較-更新的原子性」。他是非阻塞的仍是原子性，也就是說這玩意效率更高。仍是經過硬件保證的說明這玩意更可靠。

從上圖能夠看出，在cas指令修改變量值的時候，先要進行值的判斷，若是值和原來的值相等說明尚未被其它線程改過，則執行修改，若是被改過了，則不修改。在java裏邊java.util.concurrent.atomic包下邊的類都使用了CAS操做。最經常使用的方法就是compareAndSet。其底層是調用的Unsafe類的compareAndSwap方法。