0. 前言

轉載請註明出處：http://blog.csdn.net/seu_calvin/article/details/52370068

面試時很可能遇到這樣一個問題：使用volatile修飾int型變數i，多個執行緒同時進行i++操作，這樣可以實現執行緒安全嗎？提到執行緒安全、執行緒同步，我們經常會想到兩個關鍵字：volatile和synchronized，那麼這兩者有什麼區別呢？

1. volatile修飾的變數具有可見性

volatile是變數修飾符，其修飾的變數具有可見性。

可見性也就是說一旦某個執行緒修改了該被volatile修飾的變數，它會保證修改的值會立即被更新到主存，當有其他執行緒需要讀取時，可以立即獲取修改之後的值。

在Java中為了加快程式的執行效率，對一些變數的操作通常是在該執行緒的暫存器或是CPU快取上進行的，之後才會同步到主存中，而加了volatile修飾符的變數則是直接讀寫主存。

例子請檢視下面的3.1，幫助理解。

2. volatile禁止指令重排 

volatile可以禁止進行指令重排。

指令重排是指處理器為了提高程式執行效率，可能會對輸入程式碼進行優化，它不保證各個語句的執行順序同程式碼中的順序一致，但是它會保證程式最終執行結果和程式碼順序執行的結果是一致的。指令重排序不會影響單個執行緒的執行，但是會影響到執行緒併發執行的正確性。

程式執行到volatile修飾變數的讀操作或者寫操作時，在其前面的操作肯定已經完成，且結果已經對後面的操作可見，在其後面的操作肯定還沒有進行。

例子請檢視下面3.2，幫助理解。

3.  synchronized 

synchronized可作用於一段程式碼或方法，既可以保證可見性，又能夠保證原子性。

可見性體現在：通過synchronized或者Lock能保證同一時刻只有一個執行緒獲取鎖然後執行同步程式碼，並且在釋放鎖之前會將對變數的修改重新整理到主存中。

原子性表現在：要麼不執行，要麼執行到底。

例子請檢視下面3.3，幫助理解。

2. 總結
（1）從而我們可以看出volatile雖然具有可見性但是並不能保證原子性。

（2）效能方面，synchronized關鍵字是防止多個執行緒同時執行一段程式碼，就會影響程式執行效率，而volatile關鍵字在某些情況下效能要優於synchronized。

但是要注意volatile關鍵字是無法替代synchronized關鍵字的，因為volatile關鍵字無法保證操作的原子性。

3. volatile與synchronized的使用場景舉例（結合第1部分進行理解學習）

3.1 volatile的使用舉例

class MyThread extends Thread {           
    private volatile boolean isStop = false;        
    public void run() {    
        while (!isStop) {    
            System.out.println("do something");    
        }    
    }    
    public void setStop() {    
        isStop = true;    
    }          
}  

執行緒執行run()的時候我們需要線上程中不停的做一些事情，比如while迴圈，那麼這時候該如何停止執行緒呢？如果執行緒做的事情不是耗時的，那麼只需要使用一個標誌即可。如果需要退出時，呼叫setStop()即可。這裡就使用了關鍵字volatile，這個關鍵字的目的是如果修改了isStop的值，那麼在while迴圈中可以立即讀取到修改後的值。

如果執行緒做的事情是耗時的，那麼可以使用interrupt方法終止執行緒 。如果在子執行緒“睡覺”時被interrupt，那麼子執行緒可以catch到InterruptExpection異常，處理異常後繼續往下執行。

3.2 volatile的使用舉例

//執行緒1:
context = loadContext();   //語句1  context初始化操作
inited = true;             //語句2
 
//執行緒2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

因為指令重排序，有可能語句2會在語句1之前執行，可能導致context還沒被初始化，而執行緒2中就使用未初始化的context去進行操作，導致程式出錯。

這裡如果用volatile關鍵字對inited變數進行修飾，就不會出現這種問題了。

3.3 必須使用synchronized而不能使用volatile的場景

public class Test {
    public volatile int inc = 0;
    public void increase() {
        inc++;
    }
     
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
         
        while(Thread.activeCount()>1)  //保證前面的執行緒都執行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

例子中用new了10個執行緒，分別去呼叫1000次increase()方法，每次執行結果都不一致，都是一個小於10000的數字。自增操作不是原子操作，volatile 是不能保證原子性的。回到文章一開始的例子，使用volatile修飾int型變數i，多個執行緒同時進行i++操作。比如有兩個執行緒A和B對volatile修飾的i進行i++操作，i的初始值是0，A執行緒執行i++時剛讀取了i的值0，就切換到B執行緒了，B執行緒（從記憶體中）讀取i的值也為0，然後就切換到A執行緒繼續執行i++操作，完成後i就為1了，接著切換到B執行緒，因為之前已經讀取過了，所以繼續執行i++操作，最後的結果i就為1了。同理可以解釋為什麼每次執行結果都是小於10000的數字。
但是使用synchronized對部分程式碼進行如下修改，就能保證同一時刻只有一個執行緒獲取鎖然後執行同步程式碼。執行結果必然是10000。

public  int inc = 0;
public synchronized void increase() {
        inc++;
}

本文整理參考自：
http://www.cnblogs.com/dolphin0520/p/3920373.html以及warmor的部落格。
--------------------- 
作者：SEU_Calvin 
來源：CSDN 
原文：https://blog.csdn.net/SEU_Calvin/article/details/52370068 
版權宣告：本文為博主原創文章，轉載請附上博文連結！