當前位置：首頁 > 编程语言 > java >内容正文

java

Java核心知识体系8：Java如何保证线程安全性

發布時間：2023/12/24 java 68 coder

生活随笔收集整理的這篇文章主要介紹了 Java核心知识体系8：Java如何保证线程安全性小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Java核心知識體系1：泛型機制詳解
Java核心知識體系2：注解機制詳解
Java核心知識體系3：異常機制詳解
Java核心知識體系4：AOP原理和切面應用
Java核心知識體系5：反射機制詳解
Java核心知識體系6：集合框架詳解
Java核心知識體系7：線程不安全分析

1 Java內存模型（JMM）如何解決并發問題

維度1：使用關鍵字、屬性進行優化
JMM本質實際就是：Java 內存模型規范了 JVM 如何提供按需禁用緩存和編譯優化的方法。這些方法包括了：

volatile、synchronized 和 final 關鍵字
Happens-Before 規則

維度2：從順序一致性、可見性、有序性、原子性角度

順序一致性

一個線程中的所有操作按照程序的順序執行，不受其他線程的影響。

原子性

Java程序中，對數據的讀和寫操作是原子性操作，即這些操作是不可被中斷的，要么執行，要么不執行，否則會產生問題。
通過下面的案例可以看出，哪些是原子操作，哪些是非原子操作：

// 1個動作，線程直接將值賦給idx，也就是直接寫到內存中
idx = 100

// 3個動作：先定義 jdx，再讀取idx的值，最后賦值給jdx
jdx := idx

// 3個動作：讀取jdx的值，進行加1操作，然后新值重新寫入新的值
jdx ++

從上面的案例中可以看中，只有第一個例子才是具備原子性的，因為他只有一個存的動作。至于其他的例子，包含讀取、操作、賦值等多個動作，有一個動作失敗則不成立。
所以，基本讀取和賦值，Java內存模型可以保證原子性操作，如果要實現更大范圍、步驟更多的操作的原子性，則需要通過synchronized或者Lock來實現。
synchronized和Lock的存在是為了夠保證任一時刻只有一個線程能夠執行該代碼塊，這樣也就解決了原子性。

可見性

Java提供了volatile關鍵字來保證可見性，使用volatile來修飾共享變量，可以保證修改的值立即更新到主存中。這樣其他線程讀取數據時，始終都會從內存中讀取到新值。
而普通的共享變量不能保證可見性，因為修改之后，不確定什么時候被寫入主存，當其他Thread去讀取時，內存中很有可能還是原來的舊值，所以無法保證可見性。
另外，通過synchronized關鍵字和Lock功能也能夠保證可見性，因為能限制同一時刻只有一個線程獲取鎖然后執行同步代碼，且在釋放之前會將變量的修改更新到主存中。所以實時可見。

有序性

在Java里面，可以通過volatile關鍵字來保證一定的“有序性”。
另外，通過synchronized關鍵字和Lock功能也能夠保證可見性，因為能限制同一時刻只有一個線程獲取鎖然后執行同步代碼，相當于是讓線程順序執行同步代碼，自然就保證了有序性。
注：JMM是通過Happens-Before 規則來保證Thread操作有序性。

2.1 關鍵字: volatile、synchronized 和 final

在Java中，volatile、synchronized和final是三個非常重要的關鍵字，它們都與并發編程密切相關。下面是對這三個關鍵字的詳細介紹：

2.1.1 volatile

volatile是Java中的一種修飾符，它用于聲明一個共享變量，以確保多個線程對該變量的訪問是可見的和有序的。volatile關鍵字的作用是禁止指令重排和強制刷新緩存，以保證操作的順序性和可見性。
當一個變量被聲明為volatile時，它表示該變量的值可能會被意想不到地改變。編譯器和處理器會注意到這個變量的特殊性，并采取相應的措施來保證多個線程對該變量的訪問是正確的。具體來說，volatile關鍵字會禁止編譯器對volatile變量進行優化，每次讀取該變量時都會直接從它的內存地址中讀取，而不是從寄存器或緩存中讀取。同時，volatile關鍵字也會強制處理器在每個操作該變量的指令之后立即刷新緩存，以保證其他線程能夠看到最新的值。
需要注意的是，雖然volatile關鍵字可以保證可見性和有序性，但它并不能保證原子性。也就是說，如果一個操作包含多個步驟，而這些步驟不能被一個指令替換，那么這個操作就不能被保證為原子性。在這種情況下，需要使用鎖或者其他同步機制來保證原子性。

2.1.2 synchronized

synchronized是Java中的一種關鍵字，它用于實現同步代碼塊和方法。synchronized關鍵字可以保證同一時刻只有一個線程能夠執行被synchronized修飾的代碼塊或方法。synchronized關鍵字會創建一個鎖對象或鎖標識符，當一個線程獲取了這個鎖對象或鎖標識符后，其他線程就不能再獲取這個鎖對象或鎖標識符，直到第一個線程釋放了這個鎖對象或鎖標識符。
synchronized關鍵字可以保證多個線程對共享變量的訪問是互斥的，也就是說在同一時刻只有一個線程能夠訪問共享變量。這樣可以避免多個線程同時修改共享變量而導致數據不一致的問題。同時，synchronized關鍵字還可以保證多個線程之間的操作是有序的，即一個線程在執行synchronized代碼塊或方法之前必須等待其他線程完成之前的操作。
需要注意的是，synchronized關鍵字雖然可以保證互斥性和有序性，但它并不能保證原子性。也就是說，如果一個操作包含多個步驟，而這些步驟不能被一個指令替換，那么這個操作就不能被保證為原子性。在這種情況下，需要使用其他同步機制來保證原子性。

2.1.3 final

final是Java中的一種修飾符，它用于聲明一個最終變量或方法。final關鍵字表示該變量或方法不能被修改或重寫。具體來說，final關鍵字可以用于聲明一個常量，該常量的值不能被修改；也可以用于聲明一個方法，該方法不能被重寫。
final關鍵字在并發編程中也有著重要的作用。final關鍵字可以保證一個共享變量的值只被一個線程修改，這樣可以避免多個線程同時修改共享變量而導致數據不一致的問題。同時，final關鍵字還可以保證一個方法的執行不會被其他線程中斷或干擾，這樣可以保證方法的原子性和可見性。
需要注意的是，final關鍵字并不能保證多個線程之間的操作是有序的。也就是說，在一個線程中執行final方法時，其他線程可能會同時執行自己的操作，而這些操作之間是沒有順序關系的。在這種情況下，需要使用其他同步機制來保證操作的順序性。

2.2 Happens-Before 規則

上面提到了可以用 volatile 和 synchronized 來保證有序性。除此之外，在JVM 中還有Happens-Before規則，用來確定并發操作之間的順序關系。
Happens-Before規則定義了以下幾種順序關系：

2.2.1 程序順序規則（Program Order Rule）

在一個程序中，按照代碼的順序，先執行的操作Happens-Before后執行的操作。這意味著在程序中，如果一個操作先于另一個操作執行，那么這個操作的結果對后續操作是可見的。

2.2.2 管程鎖定規則（Monitor Lock Rule）

一個unlock操作先行發生于后面對同一個鎖的lock操作。

2.2.3 volatile變量規則（Volatile Variable Rule）

對一個 volatile 變量的寫操作先行發生于后面對這個變量的讀操作，先寫后讀。

2.2.4 線程啟動規則（Thread Start Rule）

Thread 對象的 start() 方法調用先行發生于此線程的每一個動作。

2.2.5 線程加入規則(（Thread Join Rule）

Thread 對象的結束先行發生于 join() 方法返回。

2.2.6 線程終止規則（Thread Termination Rule）

線程中的所有操作都先行發生于對此線程的終止檢測，我們可以通過Thread.join()方法和Thread.isAlive()的返回值等手段檢測線程是否已經終止執行

2.2.7 線程中斷規則（ Thread Interruption Rule）

對線程 interrupt() 方法的調用先行發生于被中斷線程的代碼檢測到中斷事件的發生，可以通過 interrupted() 方法檢測到是否有中斷發生。

2.2.8 對象終結規則（Finalizer Rule）

一個對象的初始化完成(構造函數執行結束)先行發生于它的 finalize() 方法的開始。

2.2.9 傳遞性（Transitivity）

如果操作A先行發生于操作B，操作B先行發生于操作C，那就可以得出操作A先行發生于操作C的結論。

3 線程安全性能討論

在多線程環境中，一個類或者一個函數不管在何種運行時環境或交替執行方式，都能保證正確的行為，被安全的調用，就說明線程是安全的。
這個“正確的行為”通常包括原子性、可見性和有序性。
但是線程安全不是非真即假，共享數據按照安全程度的強弱順序可以分成以下五類:

不可變
絕對線程安全
相對線程安全
線程兼容
線程對立

按照線程安全性的強弱順序，不可變 > 絕對線程安全 > 相對線程安全 > 線程兼容 > 線程對立。

3.1 不可變（Immutable）

不可變的對象在創建后其狀態就不能被修改，因此它們自然是線程安全的。任何線程在任何時候訪問這些對象，都會看到相同的數據。
多線程環境下，應當盡量使對象成為不可變，來滿足線程安全。
不可變的類型包括:

final 關鍵字修飾的基本數據類型
String
枚舉類型
Number 部分子類，如 Long 和 Double 等數值包裝類型，BigInteger 和 BigDecimal 等大數據類型。但同為 Number 的原子類 AtomicInteger 和 AtomicLong 則是可變的

對于集合類型，可以使用 Collections.unmodifiableXXX() 方法來獲取一個不可變的集合。

XXX 可以是Map、List、Set

public class ImmutableClass {
    public static void main(String[] args) {
        Map<String, Integer> testMap = new HashMap<>();
        Map<String, Integer> testUnmodifiable = Collections.unmodifiableMap(testMap);
        testUnmodifiable.put("input-a", 1);
    }
}

執行時拋出異常

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.Collections$testUnmodifiable.put(Collections.java:1523)
    at ImmutableExample.main(ImmutableClass.java:9)

不可變狀態還可以這么理解，外部無法對數據狀態進行修改，比如

public class ImmutableClass {  
    private final int value;  
  
    public ImmutableClass(int value) {  
        this.value = value;  
    }  
  
    public int getValue() {  
        return value;  
    }  
}

在這個例子中，ImmutableClass是不可變的，因為它的構造函數是私有的，外部無法修改其狀態。因此，多個線程同時訪問和獲取ImmutableClass對象的值時，不會出現數據不一致的問題。

3.2 絕對線程安全（Absolute Thread Safety）

絕對線程安全的對象無論運行時環境如何，調用者都不需要任何額外的同步措施。這通常需要付出較大的代價來實現。

public class ThreadSafeClass {  
    private int value;  
  
    public synchronized void setValue(int value) {  
        this.value = value;  
    }  
  
    public synchronized int getValue() {  
        return value;  
    }  
}

在這個例子中，ThreadSafeClass的每個方法都使用了synchronized關鍵字進行同步。這保證了無論多少個線程同時訪問ThreadSafeClass的對象，每個線程的操作都會被串行執行，不會出現數據競爭的問題。

3.3 相對線程安全（Relative Thread Safety）

相對線程安全的對象需要保證單個操作是線程安全的，在調用的時候不需要做額外的保障措施。但在連續調用時可能需要額外的同步措施來保證調用的正確性。
Java 語言中，大部分的線程安全類都屬于這種類型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包裝的集合等。
以Hashtable為例，因為它的每個方法都是同步的。但是，如果多個線程連續調用Hashtable的不同方法（如put和get），仍然可能出現競態條件。為了避免這種情況，調用者需要在外部進行額外的同步。

在下面代碼中，如果Vector中的一個元素被線程A刪除，而線程B試圖獲取一個已經被刪除的元素，那么就會拋出 ArrayIndexOutOfBoundsException。

public class VectorUnsafeExample {
    private static Vector<Integer> vector = new Vector<>();

    public static void main(String[] args) {
        while (true) {
            for (int i = 0; i < 100; i++) {
                vector.add(i);
            }
            ExecutorService executorService = Executors.newCachedThreadPool();
            executorService.execute(() -> {
                for (int i = 0; i < vector.size(); i++) {
                    vector.remove(i);
                }
            });
            executorService.execute(() -> {
                for (int i = 0; i < vector.size(); i++) {
                    vector.get(i);
                }
            });
            executorService.shutdown();
        }
    }
}

Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
    at java.util.Vector.remove(Vector.java:831)
    at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
    at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:745)

如果要保證上面的代碼能正確執行下去，就需要對刪除元素和獲取元素的代碼進行同步。

# 獨立線程A執行刪除操作
executorService.execute(() -> {
    synchronized (vector) {
        for (int i = 0; i < vector.size(); i++) {
            vector.remove(i);
        }
    }
});
# 獨立線程B執行讀取操作
executorService.execute(() -> {
    synchronized (vector) {
        for (int i = 0; i < vector.size(); i++) {
            vector.get(i);
        }
    }
});

3.4 線程兼容（Thread Compatibility）

線程兼容的對象本身不是線程安全的，但可以通過在調用端添加額外的同步措施來保證在多線程環境下的安全使用。
Java API 中大部分的類都是屬于線程兼容的，比如ArrayList類就不是線程安全的。如果多個線程同時修改ArrayList，可能會導致數據不一致。但是，如果調用者在修改ArrayList時使用synchronized塊或其他同步機制進行同步，就可以保證線程安全。

public class ThreadCompatibleClass {  
    private int value;  
  
    public void setValue(int value) {  
        this.value = value;  
    }  
  
    public int getValue() {  
        return value;  
    }  
}

在這個例子中，ThreadCompatibleClass的方法沒有使用synchronized關鍵字進行同步。因此，如果多個線程同時修改ThreadCompatibleClass的對象，可能會導致數據不一致。

3.5 線程對立（Thread Hostility）

線程對立的對象無論如何都無法在多線程環境下并發使用，即使采取了同步措施。
一個典型的例子是Java中的ThreadLocalRandom類。這個類用于生成隨機數，并且每個線程都有其自己的隨機數生成器實例。由于每個線程使用不同的實例，因此無需擔心線程安全問題。但是，如果嘗試在沒有正確初始化ThreadLocalRandom的情況下跨線程使用它，就可能導致問題。
這種情況下，即使添加了同步措施也無法保證線程安全。

4 如何實現線程安全

4.1 synchronized關鍵字/ReentrantLock特性

synchronized關鍵字

在Java中，synchronized關鍵字是一種內置的同步機制，用于控制多個線程對共享資源的訪問。它用于在并發環境中保護代碼塊，確保同一時刻只有一個線程可以執行該代碼塊。
synchronized關鍵字可以應用于方法或代碼塊。當它應用于方法時，它將鎖住該方法的對象。當它應用于代碼塊時，它將鎖住指定的鎖對象。

public class SynchronizedExample {  
    private int count = 0;  
  
    public synchronized void incrementCount() {  
        count++;  
    }  
}

上面這個例子中，incrementCount()方法使用了synchronized關鍵字。這意味著在任何時刻，只有一個線程可以執行該方法。如果有其他線程試圖同時執行該方法，它們將會被阻塞，直到當前線程完成該方法的執行。

ReentrantLock特性

ReentrantLock 是 Java 中的一個可重入鎖，它是一種比 synchronized 關鍵字更靈活的線程同步機制。ReentrantLock 允許一個線程多次獲取同一個鎖，而不會產生死鎖。它也支持公平鎖和非公平鎖，可以根據實際需求進行選擇。
下面是一個使用 ReentrantLock 的示例：

import java.util.concurrent.locks.ReentrantLock;  
  
public class ReentrantLockExample {  
    private final ReentrantLock lock = new ReentrantLock();  
    private int count = 0;  
  
    public void incrementCount() {  
        lock.lock();  
        try {  
            count++;  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public int getCount() {  
        return count;  
    }  
}

在上面的這個例子中，我們定義了一個 ReentrantLock 和一個計數器 count。
incrementCount() 方法使用 lock.lock() 獲取鎖，然后增加計數器的值，最后使用 lock.unlock() 釋放鎖。
getCount() 方法直接返回計數器的值，無需獲取鎖。
這種方式比使用 synchronized 關鍵字更靈活，因為它可以細粒度地控制需要同步的代碼塊，而不是整個方法。

★ 后續的章節會詳細的介紹 synchronized關鍵字和ReentrantLock特性，敬請期待

4.2 非阻塞同步

在JAVA中，互斥同步最主要的問題就是線程阻塞和喚醒所帶來的開銷導致的性能問題，這種同步也稱為阻塞同步，是一種悲觀的并發策略，無論共享數據是否真的會出現競爭，它都要進行加鎖，
這樣用戶態核心態轉換、維護鎖計數器和阻塞檢查、線程喚醒等操作都會產生大量的開銷。
非阻塞同步是指在多線程環境下，不需要使用阻塞等待的方式來實現同步控制，線程可以一直進行計算操作，而不會被阻塞。下面介紹幾種手段實現非阻塞同步。

CAS
隨著硬件指令集水平的發展，我們經常使用基于沖突檢測的樂觀并發策略: 先執行操作，如果沒有其它線程爭用共享數據，那操作就成功了，否則采取補償措施(始終重試，直至成功)。這種樂觀的并發策略的許多實現都不需要將線程阻塞，因此這種同步操作稱為非阻塞同步。
樂觀鎖需要操作和沖突檢測這兩個步驟具備原子性，這里就不能再使用互斥同步來保證了，只能靠硬件來完成。硬件支持的原子性操作最典型的是: 比較并交換(Compare-and-Swap，CAS)。
CAS操作包含三個操作數 —— 內存位置（V）、預期原值（A）和新值（B）。如果內存位置V的值與預期原值A相匹配，則將內存位置的值更新為B，否則不進行任何操作。在并發環境中，CAS操作可以保證數據的一致性和線程安全性。
AtomicInteger

AtomicInteger是Java中的一個原子整數類，它提供了原子操作的更新方法，可以在多線程環境下安全地更新共享的整數變量。
AtomicInteger的更新方法包括incrementAndGet()、getAndIncrement()、decrementAndGet()、getAndDecrement()、compareAndSet()等，它們使用了 Unsafe 類的 CAS 操作，保證對共享變量的操作是原子性的。

以下代碼使用了 AtomicInteger 執行了計數操作。

import java.util.concurrent.atomic.AtomicInteger;  
  
public class AtomicIntegerExample {  
    private static AtomicInteger counter = new AtomicInteger(0);  
  
    public static void main(String[] args) {  
        // 啟動10個線程，每個線程將計數器加10  
        for (int i = 0; i < 10; i++) {  
            new Thread(() -> {  
                for (int j = 0; j < 10; j++) {  
                    counter.incrementAndGet();  
                }  
            }).start();  
        }  
  
        // 等待所有線程執行完畢  
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
  
        // 輸出計數器的值  
        System.out.println("Counter: " + counter);  
    }  
}

在這個示例中，我們使用AtomicInteger來維護一個計數器的值，并啟動了10個線程，每個線程將計數器加10次。由于AtomicInteger提供了原子操作的更新方法，因此即使多個線程同時更新計數器的值，也不會出現線程安全問題。最后，我們輸出計數器的值，可以看到它應該是100（10個線程每個線程執行10次計數器加1操作）。

ABA
如果某個線程將變量A更改為B后再更改為A，那么另一個等待CAS操作的線程會認為該變量沒有發生過改變，仍然是A，然后執行CAS操作。這樣就可能導致數據的不一致。
J.U.C 包提供了一個帶有標記的原子引用類 AtomicStampedReference 來解決這個問題，它可以通過控制變量值的版本來保證 CAS 的正確性。大部分情況下 ABA 問題不會影響程序并發的正確性，如果需要解決 ABA 問題，改用傳統的互斥同步可能會比原子類更高效。
另外，Java 8引入了一種新的原子類：LongAdder和LongAccumulator，它們內部采用了分段化的思想來解決高并發下的ABA問題。它們將內部變量分為一個數組，每個線程更新自己的分段，最后再合并結果。這種方式既解決了ABA問題，又提高了并發性能。

4.3 無同步方案

換一個思路，如果沒有方法的計算不涉及共享數據，不需要進行同步，是不是就不需要任何同步措施去保證正確性，也就沒有線程安全的問題。

棧封閉：多個線程訪問同一個方法的局部變量時，不會出現線程安全問題，因為局部變量存儲在虛擬機棧中，屬于線程私有的。
線程本地存儲(Thread Local Storage)：如果一段代碼中所需要的數據必須與其他代碼共享，那就看看這些共享數據的代碼是否能保證在同一個線程中執行。如果能保證，我們就可以把共享數據的可見范圍限制在同一個線程之內，這樣，無須同步也能保證線程之間不出現數據爭用的問題。
可重入代碼(Reentrant Code)：可以在代碼執行的任何時刻中斷它，轉而去執行另外一段代碼(包括遞歸調用它本身)，而在控制權返回后，原來的程序不會出現任何錯誤。

這塊簡單介紹，后續會有專門的章節進行學習

5 總結

了解了多線程產生的原因，以及線程不安全的原因
從可見性，原子性和有序性來闡述并發狀態下線程不安全的原因
分析了Java是怎么解決并發問題的

總結

以上是生活随笔為你收集整理的Java核心知识体系8：Java如何保证线程安全性的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： ubuntu 22.04.1安装雷池开源
下一篇： Java中获取Class对象的三种方式