深入理解java虛擬機（6）---記憶體模型與線程 & Volatile

其實關於線程的使用，之前已經寫過博客講解過這部分的內容： http://www.cnblogs.com/deman/category/621531.html JVM裡面關於多線程的部分，主要是多線程是如何實現的，以及高效併發。 1.Java記憶體模型 CPU在運行的時候，不可能把所有的東西都放在寄存器 ...

其實關於線程的使用，之前已經寫過博客講解過這部分的內容：

http://www.cnblogs.com/deman/category/621531.html

JVM裡面關於多線程的部分，主要是多線程是如何實現的，以及高效併發。

1.Java記憶體模型

CPU在運行的時候，不可能把所有的東西都放在寄存器裡面，所有需要使用記憶體。這個記憶體就是我們知道的那個記憶體。

但是實際情況是，記憶體的讀寫速度於CPU的指令操作差了幾個數量級。所以為了跟高效的使用CPU，就有高速緩存這麼一個東西。

以下是Intel 酷睿i7 6700K參數：

三級緩存8MB。

百度以下就知道這個“三級緩存”是個神馬東西。

而java的記憶體模型與物理結構非常相識，有一個主記憶體，對應我們電腦的記憶體，還有每個線程都有一個工作記憶體，對應於高速緩存。

可以看到，每個java線程都有自己獨立的記憶體。

這也就解釋了，為什麼不同線程，如果不同步的話，變數就會有併發的問題。

這裡關於工作記憶體和主記憶體的拷貝問題，是由JVM實現的，並不是正真意義上的記憶體複製。

2.記憶體間操作

1）lock，作用於主記憶體變數，把一個變數標記為線程獨占。

2）unlock，與lock正相反。

3）read，作用於主記憶體變數，它把一個變數從主記憶體傳輸到工作記憶體中。

4）load，作用於工作記憶體變數，把從read裡面獲取的變數放入工作記憶體的變數副本中。

5）use，作用於工作記憶體變數，把變數的值傳遞給執行引擎。

6）assign，作用於工作記憶體變數，把執行引擎的值複製給工作記憶體變數。同use相反

7）store，作用於工作記憶體變數，把工作記憶體變數傳輸到主記憶體中。

8）write，作用於主記憶體變數，把store獲取的值，寫入到住記憶體中的變數。

read & load， store & write成對出現。

還有其他一些規則，目的就是保證記憶體變數的操作合理，有序。

3.併發編程的三個概念

1）原子性

計一個操作要麼全部執行，要麼不執行，不能被打斷。

jvm通過lock & unlock指令來保證代碼的原子性。反映到java代碼就是synchronized.

2)可見性

可見性是指當一個程式修改變數以後，其他程式可以立即獲得這個修改的值。

3)有序性

JVM在編譯java代碼，優化的時候，會重現排布java代碼的順序。但是會保證結果時候java代碼的順序結果一致的。

public Runnable mRun1 = new Runnable() {
    @Override
    public void run() {
        int a = readFileName();
        writeFile(a);
        initialized = true;
    }
};

上面readFileName 和initialized = true;沒有必然關係，所以在實際執行的時候，可能會先執行initialized = true;

對於這個線程內的結果沒有影響。

但是如果是多線程的情況下：

    public Runnable mRun2 = new Runnable() {
        @Override
        public void run() {
            while (!initialized)
            {
                try {
                    TraceLog.i("sleep");
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            doSomeThing(context);
        }
    };

initialized = true的執行順序對線程2的結果有直接的影響。所有有序性在這種情況下，需要保證。

一般java裡面用synchronized就可以保證。但是過多的synchronized會對性能有很大的損失。

4.volatile關鍵字

volatile關鍵字修飾後的變數.有2個作用：

1）用來確保將變數的更新操作通知到其他線程,保證了新值能立即同步到主記憶體,以及每次使用前立即從主記憶體刷新.

當把變數聲明為volatile類型後,編譯器與運行時都會註意到這個變數是共用的.

但是volatile 不能保證線程是安全的，因為java裡面的運算並非原子操作。2）volatile還有一個特性就是保證指令不重新排序。現在編譯器，為了優化代碼，都會重新排序指令。如果在多個線程裡面，就會有很大的問題。

但是指令重排是JVM在它認為合理的情況下做的，所以很難模擬出這一情況。

    boolean aBoolean = false;
    public Runnable mRun1 = new Runnable() {
        @Override
        public void run() {
            aBoolean = false;
            while (!aBoolean)
            {
                doSomeThing();
            }
        }
    };

    public Runnable mRun2 = new Runnable() {
        @Override
        public void run() {
            aBoolean = true;
        }
    };

只是2個線程的例子，線程2用來關閉線程1.一般情況下，它會運行良好，但是有小概率情況下，會有問題。

aBoolean 在賦值為true的時候，沒有立刻被同步到主記憶體，而這時候線程1的工作記憶體aBoolean 的拷貝是false。

所以會陷入死迴圈。

volatile關鍵字就可以避免這種情況的發生。

1）當aBoolean = true;發生後，線程2會立即把aBoolean 的值更新到主記憶體。

2）線程1在使用到aBoolean 是，會首先到主記憶體重新獲取新的值。然後更新工作記憶體中的值，這個時候 aBoolean就是true了，迴圈退出。

5.volatile 保證原子操作嗎？

volatile不能保證線程是安全的。

package com.joyfulmath.jvmexample.multithread;

import com.joyfulmath.jvmexample.TraceLog;

import java.util.concurrent.CountDownLatch;

/**
 * @author deman.lu
 * @version on 2016-05-26 14:34
 */
public class VolatileTest2 {
    public volatile int inc = 0;
    static CountDownLatch countDownLatch = new CountDownLatch(10);
    public void increase() {
        inc++;
    }

    public static void main() {
        TraceLog.i();
        final VolatileTest2 test = new VolatileTest2();
        for(int i=0;i<200;i++){
            new Thread(){
                @Override
                public void run() {
                    super.run();
                    for(int j=0;j<50;j++)
                        test.increase();

                    countDownLatch.countDown();
//                    TraceLog.i(String.valueOf(Thread.currentThread().getId()));
                }
            }.start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(test.inc);
        TraceLog.i(String.valueOf(test.inc));
    }
}

05-26 14:48:06.060 15209-15209/com.joyfulmath.jvmexample I/System.out: 9950
05-26 14:48:06.061 15209-15209/com.joyfulmath.jvmexample I/VolatileTest2: main: 9950 [at (VolatileTest2.java:41)]

結果並不是10000，原因就是自增函數不是原子操作，而Volatile只能保證數值是更新到住記憶體，但是，當線程1執行過程中假設inc=5，線程2可能已經獲取了inc的值。

這個時候，線程1，++以後變為6，線程2也是6，而且因為主記憶體的值 & 線程2的值一致，就不會觸發其他線程無效的情況，所以線程3取到的值，還是6.所有這個數值的結果是無法確認的，但是<10000.

But, 我在android23下編譯，發現一直是10000.不清楚原因？？？

6.volatile的有序性

volatile只能保證部分有序性，比如說:

1 volatile boolean initialized = false;
2         public void run() {
3             context = readFileName();
4             writeFile(context);
5             initialized = true;
6             play();
7             Drawable();
8         }

上面，3，4兩行語句順序是亂序的，6，7也是，但是5 一定在3，4之後運行。也就是5的執行為止不變，而且，3，4 不能和6，7互換執行順序。這就是volatile有限的有序性。

參考：

http://www.cnblogs.com/dolphin0520/p/3920373.html

《深入理解java虛擬機》周志明