并發編程三大特性

原子性

一個操作或者多次操作，要么所有的操作全部都得到執行并且不會受到任何因素的干擾而中斷，要么所有的操作都執行，要么都不執行。

對于基本數據類型的訪問，讀寫都是原子性的【long和double可能例外】。

如果需要更大范圍的原子性保證，可以使用synchronized關鍵字滿足。

可見性

當一個變量對共享變量進行了修改，另外的線程都能立即看到修改后的最新值。

volatile保證共享變量可見性，除此之外，synchronized和final都可以實現可見性。

synchronized：對一個變量執行unclock之前，必須先把此變量同步回主內存中。

final：被final修飾的字段在構造器中一旦被初始化完成，并且構造器沒有把this的引用傳遞出去，其他線程中就能夠看見final字段的值。

有序性

即程序執行的順序按照代碼的先后順序執行【由于指令重排序的存在，Java 在編譯器以及運行期間對輸入代碼進行優化，代碼的執行順序未必就是編寫代碼時候的順序】，volatile通過禁止指令重排序保證有序性，除此之外，synchronized關鍵字也可以保證有序性，由【一個變量在同一時刻只允許一條線程對其進行lock操作】這條規則獲得。

CPU緩存模型是什么

高速緩存為何出現？

計算機在執行程序時，每條指令都是在CPU中執行的，而執行指令過程中，勢必涉及到數據的讀取和寫入。由于程序運行過程中的**臨時數據是存放在主存（物理內存）**當中的，這時就存在一個問題，由于CPU執行速度很快，而從內存讀取數據和向內存寫入數據的過程跟CPU執行指令的速度比起來要慢的多，因此如果任何時候對數據的操作都要通過和內存的交互來進行，會大大降低指令執行的速度。

為了解決CPU處理速度和內存不匹配的問題，CPU Cache出現了。

圖源：JavaGuide

緩存一致性問題

當程序在運行過程中，會將運算需要的數據從主存復制一份到CPU的高速緩存當中，那么CPU進行計算時就可以直接從它的高速緩存讀取數據和向其中寫入數據，當運算結束之后，再將高速緩存中的數據刷新到主存當中。

在單線程中運行是沒有任何問題的，但是在多線程環境下問題就會顯現。舉個簡單的例子，如下面這段代碼：

i = i + 1;

按照上面分析，主要分為如下幾步：

從主存讀取i的值，復制一份到高速緩存中。
CPU執行執行執行對i進行加1操作，將數據寫入高速緩存。
運算結束后，將高速緩存中的數據刷新到內存中。

多線程環境下，可能出現什么現象呢？

初始時，兩個線程分別讀取i的值，存入各自所在的CPU高速緩存中。
線程T1進行加1操作，將i的最新值1寫入內存。
此時線程T2的高速緩存中i的值還是0，進行加1操作，并將i的最新值1寫入內存。

最終的結果i = 1而不是i = 2，得出結論：如果一個變量在多個CPU中都存在緩存（一般在多線程編程時才會出現），那么就可能存在緩存不一致的問題。

如何解決緩存不一致

解決緩存不一致的問題，通常來說有如下兩種解決方案【都是在硬件層面上提供的方式】：

通過在總線加LOCK#鎖的方式

在早期的CPU當中，是通過在總線上加LOCK#鎖的形式來解決緩存不一致的問題。因為CPU和其他部件進行通信都是通過總線來進行的，如果對總線加LOCK#鎖的話，也就是說阻塞了其他CPU對其他部件訪問（如內存），從而使得只能有一個CPU能使用這個變量的內存。比如上面例子中如果一個線程在執行 i = i +1，如果在執行這段代碼的過程中，在總線上發出了LCOK#鎖的信號，那么只有等待這段代碼完全執行完畢之后，其他CPU才能從變量i所在的內存讀取變量，然后進行相應的操作。這樣就解決了緩存不一致的問題。

但，有一個問題，在鎖住總線期間，其他CPU無法訪問內存，導致效率低下，于是就出現了下面的緩存一致性協議。

通過緩存一致性協議

較著名的就是Intel的MESI協議，MESI協議保S證了每個緩存中使用的共享變量的副本是一致的。

當CPU寫數據時，如果發現操作的變量是共享變量，即在其他CPU中也存在該變量的副本，會發出信號通知其他CPU將該變量的緩存行置為無效狀態，因此當其他CPU需要讀取這個變量時，發現自己緩存中緩存該變量的緩存行是無效的【嗅探機制：每個處理器通過嗅探在總線上傳播的數據來檢查自己的緩存的值是否過期】，那么它就會從內存重新讀取。

基于MESI一致性協議，每個處理器需要不斷從主內存嗅探和CAS不斷循環，無效交互會導致總線帶寬達到峰值，出現總線風暴。

JMM內存模型是什么

JMM【Java Memory Model】：Java內存模型，是java虛擬機規范中所定義的一種內存模型，Java內存模型是標準化的，屏蔽掉了底層不同計算機的區別，以實現讓Java程序在各種平臺下都能達到一致的內存訪問效果。

它描述了Java程序中各種變量【線程共享變量】的訪問規則，以及在JVM中將變量存儲到內存和從內存中讀取變量這樣的底層細節。

注意，為了獲得較好的執行性能，Java內存模型并沒有限制執行引擎使用處理器的寄存器或者高速緩存來提升指令執行速度，也沒有限制編譯器對指令進行重排序。也就是說，在java內存模型中，也會存在緩存一致性問題和指令重排序的問題。

JMM的規定

所有的共享變量都存儲于主內存，這里所說的變量指的是【實例變量和類變量】，不包含局部變量，因為局部變量是線程私有的，因此不存在競爭問題。

每個線程都有自己的工作內存（類似于前面的高速緩存）。線程對變量的所有操作都必須在工作內存中進行，而不能直接對主存進行操作。

每個線程不能訪問其他線程的工作內存。

Java對三大特性的保證

原子性

在Java中，對基本數據類型的變量的讀取和賦值操作是原子性操作，即這些操作是不可被中斷的，要么執行，要么不執行。

為了更好地理解上面這句話，可以看看下面這四個例子：

x = 10;  	//1
y = x;   	//2
x ++;    	//3
x = x + 1;  //4

只有語句1是原子性操作：直接將數值10賦值給x，也就是說線程執行這個語句的會直接將數值10寫入到工作內存中。
語句2實際包含兩個操作：先去讀取x的值，再將x的值寫入工作內存，雖然兩步分別都是原子操作，但是合起來就不能算作原子操作了。
語句3和4表示：先讀取x的值，進行加1操作，寫入新的值。

需要注意的點：

在32位平臺下，對64位數據的讀取和賦值是需要通過兩個操作來完成的，不能保證其原子性。在目前64位JVM中，已經保證對64位數據的讀取和賦值也是原子性操作了。
Java內存模型只保證了基本讀取和賦值是原子性操作，如果要實現更大范圍操作的原子性，可以通過synchronized和Lock來實現。

可見性

Java提供了volatile關鍵字來保證可見性。

當一個共享變量被volatile修飾時，它會保證修改的值會立即被更新到主存，當有其他線程需要讀取時，它會去內存中讀取新值。

另外，通過synchronized和Lock也能夠保證可見性，synchronized和Lock能保證同一時刻只有一個線程獲取鎖然后執行同步代碼，并且在釋放鎖之前會將對變量的修改刷新到主存當中。因此可以保證可見性。

有序性

在Java內存模型中，允許編譯器和處理器對指令進行重排序，但是重排序過程不會影響到單線程程序的執行，卻會影響到多線程并發執行的正確性。

在Java里面，可以通過volatile關鍵字來保證有序性，另外也可以通過synchronized和Lock來保證有序性。

Java內存模型具備一些先天的有序性，前提是兩個操作滿足happens-before原則，摘自《深入理解Java虛擬機》：

程序次序規則：一個線程內，按照代碼順序，書寫在前面的操作先行發生于書寫在后面的操作【讓程序看起來像是按照代碼順序執行，虛擬機只會對不存在數據依賴性的指令進行重排序，只能保證單線程中執行結果的正確性，多線程結果正確性卻無法保證】
鎖定規則：一個unLock操作先行發生于后面對同一個鎖額lock操作
volatile變量規則：對一個變量的寫操作先行發生于后面對這個變量的讀操作
傳遞規則：如果操作A先行發生于操作B，而操作B又先行發生于操作C，則可以得出操作A先行發生于操作C
線程啟動規則：Thread對象的start()方法先行發生于此線程的每個一個動作
線程中斷規則：對線程interrupt()方法的調用先行發生于被中斷線程的代碼檢測到中斷事件的發生
線程終結規則：線程中所有的操作都先行發生于線程的終止檢測，我們可以通過Thread.join()方法結束、Thread.isAlive()的返回值手段檢測到線程已經終止執行
對象終結規則：一個對象的初始化完成先行發生于他的finalize()方法的開始

如果兩個操作的執行次序無法從happens-before原則推導出來，那么它們就不能保證它們的有序性，虛擬機可以隨意地對它們進行重排序。

volatile解決的問題

保證了不同線程對共享變量【類的成員變量，類的靜態成員變量】進行操作是時的可見性，一個線程修改了某個變量的值，新值對其他線程來說是立即可見的。
禁止指令重排序。

舉個簡單的例子，看下面這段代碼：

//線程1
boolean volatile stop = false;
while(!stop){doSomething();
}
//線程2
stop = true;

線程1和2各自都擁有自己的工作內存，線程1和線程2首先都會將stop變量的值拷貝一份放到自己的工作內存中，
共享變量stop通過volatile修飾，線程2將stop的值改為true將會立即寫入主內存。
線程2寫入主內存之后，導致線程1工作內存中緩存變量stop的緩存行無效。
線程1的工作內存中緩存變量stop的緩存行無效，導致線程1會再次從主存中讀取stop值。

volatile保證原子性嗎？怎么解決？

volatile無法保證原子性，如對一個volatile修飾的變量進行自增操作i ++，無法保證多線程下結果的正確性。

解決方法：

使用synchronized關鍵字或者Lock加鎖，保證某個代碼塊在同一時刻只能被一個線程執行。
使用JUC包下的原子類，如AtomicInteger等。【Atomic利用CAS來實現原子操作】。

volatile的實現原理

下面這段話摘自《深入理解Java虛擬機》：

觀察加入volatile關鍵字和沒有加入volatile關鍵字時所生成的匯編代碼發現，加入volatile關鍵字時，會多出一個lock前綴指令。

lock前綴指令實際上相當于一個內存屏障（也成內存柵欄），內存屏障會提供3個功能：

它確保指令重排序時不會把其后面的指令排到內存屏障之前的位置，也不會把前面的指令排到內存屏障的后面；即在執行到內存屏障這句指令時，在它前面的操作已經全部完成；
它會強制將對緩存的修改操作立即寫入主存；
如果是寫操作，它會導致其他CPU中對應的緩存行無效。

volatile和synchronized的區別

volatile變量讀操作的性能消耗與普通變量幾乎沒有什么差別，但是寫操作則會慢一些，因為它需要在本地代碼中插入許多內存屏障指令來保證處理器不發生亂序執行。不過即便如此，大多數場景下volatile的總開銷仍然要比鎖來的低。

volatile只能用于變量，而synchronized可以修飾方法以及代碼塊。
volatile能保證可見性，但是不能保證原子性。synchronized兩者都能保證。如果只是對一個共享變量進行多個線程的賦值，而沒有其他的操作，推薦使用volatile，它更加輕量級。
volatile 關鍵字主要用于解決變量在多個線程之間的可見性，而 synchronized 關鍵字解決的是多個線程之間訪問資源的同步性。