執行緒安全就是多執行緒訪問時，採用了加鎖機制，當一個執行緒訪問該類的某個資料時，進行保護，其他執行緒不能進行訪問直到該執行緒讀取完，其他執行緒才可使用。不會出現資料不一致或者資料汙染。
執行緒不安全就是不提供資料訪問保護，有可能出現多個執行緒先後更改資料造成所得到的資料是髒資料

1. 概念

如果你的程式碼所在的程序中有多個執行緒在同時執行，而這些執行緒可能會同時執行這段程式碼。如果每次執行結果和單執行緒執行的結果是一樣的，而且其他的變數的值也和預期的是一樣的，就是執行緒安全的。
或者說，一個類或者程式所提供的介面對於執行緒來說是原子操作或者多個執行緒之間的切換不會導致該介面的執行結果存在二義性,也就是說我們不用考慮同步的問題。
執行緒安全問題都是由全域性變數及靜態變數引起的。(這句還未考證，但對全域性變數和靜態變數操作在多執行緒模型中會引發執行緒不安全)

2. 安全性

比如一個 ArrayList 類，在新增一個元素的時候，它可能會有兩步來完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。
在單執行緒執行的情況下，如果 Size = 0，新增一個元素後，此元素在位置 0，而且 Size=1；
而如果是在多執行緒情況下，比如有兩個執行緒，執行緒 A 先將元素存放在位置 0。但是此時 CPU 排程執行緒A暫停，執行緒 B 得到執行的機會。執行緒B也向此 ArrayList 新增元素，因為此時 Size 仍然等於 0 （注意哦，我們假設的是新增一個元素是要兩個步驟哦，而執行緒A僅僅完成了步驟1），所以執行緒B也將元素存放在位置0。然後執行緒A和執行緒B都繼續執行，都增加 Size 的值。
那好，我們來看看 ArrayList 的情況，元素實際上只有一個，存放在位置 0，而 Size 卻等於 2。這就是“執行緒不安全”了。

3. 執行緒同步

3.1 Synchronized(同步)

public class TraditionalThreadSynchronized {
    public static void main(String[] args) {
        final Outputter outputter = new Outputter();
        // 執行兩個執行緒分別輸出名字zhangsan和lisi
        new Thread() {
            public void run() {
                outputter.output("zhangsan"
 
);
            }
        }.start();      
        new Thread() {
            public void run() {
                outputter.output("lisi");
            }
        }.start();
    }
}
class Outputter {
    public void output(String name) {
        // TODO 為了保證對name的輸出不是一個原子操作，這裡逐個輸出name的每個字元
        for(int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i));
            // Thread.sleep(10);
        }
    }
}

執行結果：zhlainsigsan

顯然輸出的字串被打亂了，我們期望的輸出結果是zhangsanlisi，這就是執行緒同步問題，我們希望output方法被一個執行緒完整的執行完之後再切換到下一個執行緒，Java中使用synchronized保證一段程式碼在多執行緒執行時是互斥的，有兩種用法：
方法 1： 使用synchronized將需要互斥的程式碼包含起來，並上一把鎖。

{
    synchronized (this) {
        for(int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i));
        }
    }
}

這把鎖必須是需要互斥的多個執行緒間的共享物件，像下面的程式碼是沒有意義的。

{
    Object lock = new Object();
    synchronized (lock) {
        for(int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i));
        }
    }
}

方法2：將synchronized加在需要互斥的方法上。

public synchronized void output(String name) {
    // TODO 執行緒輸出方法
    for(int i = 0; i < name.length(); i++) {
        System.out.print(name.charAt(i));
    }
}

這種方式就相當於用this鎖住整個方法內的程式碼塊，如果用synchronized加在靜態方法上，就相當於用××××.class鎖住整個方法內的程式碼塊。使用synchronized在某些情況下會造成死鎖，死鎖問題以後會說明。使用synchronized修飾的方法或者程式碼塊可以看成是一個 原子操作。

每個鎖物件(JLS(java語言規範)中叫monitor)都有兩個佇列，一個是就緒佇列，一個是阻塞佇列，就緒佇列儲存了將要獲得鎖的執行緒，阻塞佇列儲存了被阻塞的執行緒，當一個執行緒被喚醒(notify)後，才會進入到就緒佇列，等待CPU的排程，反之，當一個執行緒被wait後，就會進入阻塞佇列，等待下一次被喚醒，這個涉及到執行緒間的通訊。看我們的例子，當第一個執行緒執行輸出方法時，獲得同步鎖，執行輸出方法，恰好此時第二個執行緒也要執行輸出方法，但發現同步鎖沒有被釋放，第二個執行緒就會進入就緒佇列，等待鎖被釋放。一個執行緒執行互斥程式碼過程如下：

    1. 獲得同步鎖；

    2. 清空工作記憶體；

    3. 從主記憶體拷貝物件副本到工作記憶體；

    4. 執行程式碼(計算或者輸出等)；

    5. 重新整理主記憶體資料；

    6. 釋放同步鎖。

    所以，synchronized既保證了多執行緒的併發有序性，又保證了多執行緒的記憶體可見性。

#### 3.2 Volatile
用volatile修飾的變數，執行緒在每次使用變數的時候，都會讀取變數修改後的最的值。volatile很容易被誤用，用來進行原子性操作。(那應該如何使用呢？？)

public class Counter {

    public static int count = 0;

    public static void inc() {

        //這裡延遲1毫秒，使得結果明顯
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }
        count++;
    }

    public static void main(String[] args) {

        //同時啟動1000個執行緒，去進行i++計算，看看實際結果

        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }

        //這裡每次執行的值都有可能不同,可能為1000
        System.out.println("執行結果:Counter.count=" + Counter.count);
    }
}

執行結果:Counter.count=995

實際運算結果每次可能都不一樣，本機的結果為：執行結果:Counter.count=995，可以看出，在多執行緒的環境下，Counter.count並沒有期望結果是1000
很多人以為，這個是多執行緒併發問題，只需要在變數count之前加上volatile就可以避免這個問題，那我們在修改程式碼看看，看看結果是不是符合我們的期望。

public class Counter {
    // 在count上使用volatile關鍵字
    public volatile static int count = 0;

    public static void inc() {

        //這裡延遲1毫秒，使得結果明顯
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }

        count++;
    }

    public static void main(String[] args) {

        //同時啟動1000個執行緒，去進行i++計算，看看實際結果

        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }

        //這裡每次執行的值都有可能不同,可能為1000
        System.out.println("執行結果:Counter.count=" + Counter.count);
    }
}

執行結果:Counter.count=992

執行結果還是沒有我們期望的1000，下面我們分析一下原因
在 java 垃圾回收整理一文中，描述了jvm執行時刻記憶體的分配。其中有一個記憶體區域是JVM棧，每一個執行緒執行時都有一個執行緒棧，執行緒棧儲存了執行緒執行時候變數值資訊。當執行緒訪問某一個物件時候值的時候，首先通過物件的引用找到對應在堆記憶體的變數的值，然後把堆記憶體變數的具體值load到執行緒本地記憶體中，建立一個變數副本，之後執行緒就不再和物件在堆記憶體變數值有任何關係，而是直接修改副本變數的值，在修改完之後的某一個時刻（執行緒退出之前），自動把執行緒變數副本的值回寫到物件在堆中變數。這樣在堆中的物件的值就產生變化了。下面一幅圖描述這些互動：

read and load 從主存複製變數到當前工作記憶體
use and assign 執行程式碼，改變共享變數值
store and write 用工作記憶體資料重新整理主存相關內容

其中use and assign 可以多次出現

但是這一些操作並不是原子性，也就是 在read load之後，如果主記憶體count變數發生修改之後，執行緒工作記憶體中的值由於已經載入，不會產生對應的變化，所以計算出來的結果會和預期不一樣

對於volatile修飾的變數，jvm虛擬機器只是保證從主記憶體載入到執行緒工作記憶體的值是當前最新的

例如假如執行緒1，執行緒2 在進行read,load 操作中，發現主記憶體中count的值都是5，那麼都會載入這個最新的值

線上程1堆count進行修改之後，會write到主記憶體中，主記憶體中的count變數就會變為6

執行緒2由於已經進行read,load操作，在進行運算之後，也會更新主記憶體count的變數值為6

導致兩個執行緒及時用volatile關鍵字修改之後，還是會存在併發的情況。(所以volatile用來幹啥？:( )