線程安全一直是多線程開發中需要注意的地方，可以說，并發安全保證了所有的數據都安全。

1 線程不安全示例

線程安全其實是多線程編程里面的一個核心點，所有的設計和代碼都是為了實現線程的高效與安全。

多線程中有幾個比較核心概念，即原子性，可見性，順序性。那么線程安全也會圍繞著這三個核心來展開嘍。

下面我們看一兩個簡單的問題多線程。

簡單買票的線程安全問題

public class ThreadSafeDemo3 {
    public static void main(String[] args) throws InterruptedException {
        TicketStation station = new TicketStation();
        new Thread(station,"軟軟").start();
        new Thread(station,"冰冰").start();
        new Thread(station,"指北君").start();
    }
}
class TicketStation implements Runnable{
    int ticketCount = 10;
    boolean hasTicket = true;
    @Override
    public void run() {
        while(hasTicket){buyTicket();}
    }
    private void buyTicket(){
        if (ticketCount < 1) {
            hasTicket = false;
            return;
        }
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " get the ticket"+ ticketCount--);
    }
}

運行幾遍就有可能會出現下面的錯誤不預期的結果。一個線程賣完了票，但是另外兩個線程都還不知道。

image-20210926221216385

多線程操作非線程安全對象問題

public class ThreadSafeDemo2 {
    public static void main(String[] args) throws InterruptedException {
        List< String > list = new ArrayList<  >();
        for (int i =0 ;i< 20 ;i++) {
            new Thread(() - > {
                for (int j = 0; j < 5; j++) {
                    list.add(Thread.currentThread().getName() + j);
                }
            }, "thread" + i).start();
        }
        Thread.sleep(1000*3);
        System.out.println(list.size());
    }
}

以上代碼多執行幾次之后會，所得list的size不會等于100。問題就在于多線程操作同一個線程不安全的List的時候，會是結果與預期不符，出現線程安全問題。

以上是兩個線程不安全的示例，而對于線程安全，應該要做到如下：

當多個線程訪問某個方法的時候，不管你通過怎樣的調用方法，或者說這些線程如何交替執行，我們在主程序中不需要去做任何的同步，這個類的行為都是我們設想的正確行為，那么我們可以說這個類是線程安全的。即可以保證原子性，可見性，順序性。

2 并發安全的問題根源

線程不安全指的是多線程并發執行某個代碼時，產生了邏輯上的錯誤，結果和預期值不相同。

其原因可以總結如下：

• Java線程是搶占執行的。
• 有些操作不是原子的，cpu在處理某一個線程的時候，有可能被其他線程搶去做工。
• 內存共享可變。
• 指令重排序：Java編譯器在編譯代碼時，會對最終執行的指令重排序，它會保證原有邏輯不變的情況下，提高程序的運行效率。

3 線程安全不是絕對的

《深入理解JVM》中有講到如果要保證絕對線程安全，在大多數的應用場景下是難以做到的，或者說很難做到，即使做到，也會付出很大的代價。而且在Java中標注的某些線程安全的類也不是絕對的線程安全，也需要在調用時使用一些額外操作。

我們大多時候都是盡量保證線程的相對安全，對一個對象單獨操作的時候保證線程安全，而對于一些特殊的調用情況，我們則需要采取一些同步操作付諸。

4 線程安全的實現方法

我們在寫代碼的時候，保證線程安全的方法有多種，下面我們介紹幾種方式。

4.1 互斥同步

互斥的特點是在同一時刻只有一個線程獲得執行權利，其余線程則會等待。( 同一時刻，只有一個線程在操作共享數據 ) 互斥是實現同步的一種手段， 臨界區、互斥量、信號量都是主要的互斥實現方式。即通過實現互斥來最終完成同步的目的。

4.1.1 Synchronized

synchronized是同步鎖，主要用來控制線程同步，保證某個鎖住的內容不被多個線程同步執行。上述買票的例子中，在buyTicket方法上加上synchronized關鍵字，就可以使線程同步執行了。

private synchronized  void  buyTicket(){}

其中synchronized 使用有幾點注意：

1. 加到非靜態方法前，表示鎖this，即當前對象
2. 加到靜態方法前，表示鎖當前類的所有類對象

4.1.2 Lock

Lock 是Java1.6之后引入的。使用Lock可以對鎖進行多種操作，可以手動的獲取鎖，釋放鎖。

我們用ReentrantLock （ReentrantLock傳送門。。。）改寫上述購票行為。

class TicketLockStation implements Runnable{
    private Lock lock = new ReentrantLock();
    int ticketCount = 10;
    boolean hasTicket = true;
    @Override
    public void run() {
        while(hasTicket){buyTicket();}
    }
    private void  buyTicket(){
        lock.lock();
        try {
        if (ticketCount < 1) {
            hasTicket = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + " get the ticket"+ ticketCount--);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

以上為簡單Lock示例，其中Lock中還有tryLock()（如果獲取不到鎖立即返回）， tryLock(long time, TimeUnit unit)（一段時間后獲取不到鎖則返回）等方法。

上邊就是Lock的簡單示例。

4.2 非阻塞同步

非阻塞同步可以描述為 基于沖突檢測的樂觀并發策略 ，關鍵點就是沖突檢測以及樂觀的并發策略。

沖突檢測是指當發生共享數據搶奪的話，我們會進行重試檢測，直到成功為止。而樂觀的并發策略的實現大多時候都不需要掛起線程。

4.2.1 CAS

CAS（Compare And Swap）是非阻塞的一個實現，其核心指令有3個操作數，分別為內存地址V， 舊值A，新值B。當CAS執行時當 V的內存地址對應的值與A匹配時，本操作就會用B來更新V對應的值，否則不執行更新。但無論是否更新了V對應的值，都會返回V處對應的舊值。而且此操作為原子操作。

CAS有一個缺點就是ABA問題，V處的值原來是A，后來變成了B,然后又變成了A。使用CAS檢查的時候發現其值沒變化，然而實際上已經發生了變化。對于解決ABA問題，可以使用版本號的思路來解決，在更新變量的時候把版本號加一。然后對比的時候也對比版本號，版本號與值全都相等則執行更新。

4.3 無同步方案

保證線程安全的方法中，也并不是一定要使用同步。同步只是在保證共享數據在有競爭條件的時候使用。如果有方法可以避免共享數據的競爭，那么自然就不需要任何同步操作去保證數據的正確。所以在有一些場景下，代碼自身就已經保證了線程安全，而無須使用同步方法。

4.3.1 棧封閉

其實主要就是盡量保證數據的操作在一個棧幀中，也就是局部變量，避免過多的去操作共享內存數據。

4.3.2 線程本地存儲

如果代碼中所需的數據必須與其他代碼共享，那么就可以看看這些共享數據的代碼是否能保證在同一個線程中執行。如果可以保證共享數據在同一個線程之內是可見的，那么線程之間也就不會出現數據的競爭。

ThreadLocal就是一個最典型的例子，Web應用中的Request也是這樣的思路。

4.3.3 可重入代碼 （Reentrant Code）

可重入代碼指在代碼執行的任何時刻中斷它，轉而去執行另外一段代碼，而控制權返回后，原來的程序不會出現任何錯誤。所有的可重入代碼都是線程安全的。一般而言可重入代碼不依賴存儲在堆上的數據以及公共的系統資源，用到的狀態量都是有參數傳入，或者說不調用，非可重入的方法等。

總結

關于線程安全，我們可以總結以下的一些思路。

1. 使用互斥同步的方法。
   • 使用Synchronized
   • 使用Lock
2. 使用非阻塞同步方案。
   • CAS 等。
3. 無同步方案
   其實就是在設計上盡量避免共享變量的使用，這樣也就可以避免線程安全問題的發生。