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有限的有序性。