深刻理解java虛擬機(6)---內存模型與線程 & Volatile

其實關於線程的使用,以前已經寫過博客講解過這部分的內容:html

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

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

1.Java內存模型

CPU在運行的時候,不可能把全部的東西都放在寄存器裏面,全部須要使用內存。這個內存就是咱們知道的那個內存。編程

可是實際狀況是,內存的讀寫速度於CPU的指令操做差了幾個數量級。因此爲了跟高效的使用CPU,就有高速緩存這麼一個東西。緩存

如下是Intel 酷睿i7 6700K參數:安全

三級緩存8MB多線程

百度如下就知道這個「三級緩存」是個神馬東西。併發

而java的內存模型與物理結構很是相識,有一個主內存,對應咱們計算機的內存,還有每一個線程都有一個工做內存,對應於高速緩存。jvm

 

能夠看到,每一個java線程都有本身獨立的內存。ide

這也就解釋了,爲何不一樣線程,若是不一樣步的話,變量就會有併發的問題。

這裏關於工做內存和主內存的拷貝問題,是由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虛擬機》周志明

相關文章
相關標籤/搜索