執行緒安全性-原子性、可見性、有序性

icesource發表於2018-10-18

執行緒安全性

當多個執行緒訪問某個類時，不管執行時環境採用何種排程方式或者這些執行緒將如何交替執行，並且在主調程式碼中不需要任何額外的同步或協同，這個類都能表現出正確的行為，那麼這個類就是執行緒安全的。

原子性：提供了互斥訪問，同一時刻只能有一個執行緒來對它進行操作
可見性：一個執行緒對主記憶體的修改可以及時被其他執行緒觀察到
有序性：一個執行緒觀察其他執行緒中的指令執行順序，由於指令重排序的存在，該觀察結果一般雜亂無序

原子性

Atomic包

這裡使用AtomicInteger進行計數，Java底層是使用CAS進行的悲觀鎖的同步。
詳解CAS： https://blog.csdn.net/v123411739/article/details/79561458
Java中的CAS： https://blog.csdn.net/mmoren/article/details/79185862

上文提到的CAS都有三個運算元，記憶體位置（V）、預期原值（A）和新值(B)。如果記憶體位置的值與預期原值相匹配，那麼處理器會自動將該位置值更新為新值。否則，處理器不做任何操作。我再理解這個概念時遇到了一個問題，在多執行緒的情況下，java如何知道預期原值。這實際上和之前的JVM記憶體模型有關。

一個執行緒間共享的變數，首先在主存中會保留一份，然後每個執行緒的工作記憶體也會保留一份副本。這裡說的預期值，就是執行緒保留的副本。當該執行緒從主存中獲取該變數的值後，主存中該變數可能已經被其他執行緒重新整理了，但是該執行緒工作記憶體中該變數卻還是原來的值，這就是所謂的預期值了。當你要用CAS重新整理該值的時候，如果發現執行緒工作記憶體和主存中不一致了，就會失敗，如果一致，就可以更新成功。

package com.ice.concurrency.example.count;
import com.ice.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@ThreadSafe
public class CountExample2 {

    public static int clientTotal = 5000;

    public static int threadTotal = 200;

    public static AtomicInteger count = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i = 0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}",count.get());
    }

    private static void add(){
        count.incrementAndGet();
    }
}

AtomicInteger呼叫了java底層的unsafe的getAndAddInt方法，這裡是實現CAS的關鍵
unsafe類下呼叫的方法大多是native方法，由jvm本地實現。在Windows環境下，CAS方法好像是由C++實現的。Linux的X86下主要是通過cmpxchgl這個指令在CPU級完成CAS操作的，但在多處理器情況下必須使用lock指令加鎖來完成。
實際上Java底層到底是如何實現CAS的，我還不是十分清楚。但目前而言，已經大致理解了CAS的原理和優缺點即可。

AtomicReferce類

@Slf4j
@ThreadSafe
public class AtomicExample4 {

    private static AtomicReference<Integer> count = new AtomicReference<>(0);

    public static void main(String[] args) {
        count.compareAndSet(0,2); // 2
        count.compareAndSet(0,1); // no
        count.compareAndSet(1,3); // no
        count.compareAndSet(2,4); // 4
        count.compareAndSet(3,5); // no
        log.info("count:{}",count.get());
    }
}
>>> count:4

AtomicIntegerFieldUpdater類

@Slf4j
@ThreadSafe
public class AtomicExample5 {

    private static AtomicIntegerFieldUpdater<AtomicExample5> updater =
            AtomicIntegerFieldUpdater.newUpdater(AtomicExample5.class,"count");

    // count欄位必須為volatile修飾且非static才能被AtomicIntegerFieldUpdater改變。
    @Getter
    public volatile int count=100;

    private static AtomicExample5 example5 = new AtomicExample5();

    public static void main(String[] args) {
        if(updater.compareAndSet(example5,100,120)){
            log.info("update success, {}",example5.getCount());
        }

        if(updater.compareAndSet(example5,100,120)){
            log.info("update success, {}",example5.getCount());
        }else{
            log.info("update failed, {}",example5.getCount());
        }
    }
}

AtomicStampReference類（解決ABA問題）

該類的核心方法compareAndSet,該類是通過一個重新定義一個stamp的值來標記當前值是否被更改過。

AtomicLongArray類

這裡是通過傳入一個index值來更新陣列內的值

AtomicBoolean類

@Slf4j
@ThreadSafe
public class AtomicExample6 {

    public static int clientTotal = 5000;

    public static int threadTotal = 200;

    public static AtomicBoolean count = new AtomicBoolean(false);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i = 0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    test();
                    semaphore.release();
                } catch (InterruptedException e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("isHappened:{}",count.get());
    }

    private static void test(){
        if(count.compareAndSet(false,true)){
            log.info("execute");
        }
    }
}

執行這段程式碼，可以看到log只列印了一次execute。因為不論多少個執行緒同時訪問AtomicBoolean，只有一個能成功修改它的值。

鎖

jdk主要提供的兩種鎖

java實現原子性的各種方法的對比

sychronized關鍵字

sychronized修飾不同目標時的作用範圍

package com.ice.concurrency.example.sync;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class SynchronizedExample1 {

    public void test(){
        for(int i = 0;i<10;i++){
            log.info("test - {}",i);
        }
    }

    // synchronized修飾一個程式碼塊
    public void test1(int j){
        synchronized (this){
            for(int i = 0;i<10;i++){
                log.info("test1 {} - {}",j,i);
            }
        }
    }

    // 修飾一個方法
    public synchronized void test2(int j){
        for(int i = 0;i<10;i++){
            log.info("test2 {} - {}",j,i);
        }
    }

    // 修飾一個類
    public static void test3(int j){
        synchronized (SynchronizedExample1.class){
            for(int i = 0;i<10;i++){
                log.info("test3 {} - {}",j,i);
            }
        }
    }

    // 修飾一個靜態方法
    public static synchronized void test4(int j){
        for(int i = 0;i<10;i++){
            log.info("test4 {} - {}",j,i);
        }
    }

    public static void main(String[] args) {
        SynchronizedExample1 example1 = new SynchronizedExample1();
        SynchronizedExample1 example2 = new SynchronizedExample1();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(()->{
            example1.test1(1);
        });
        executorService.execute(()->{
            example2.test1(2);
        });
    }
}

可見性

可見性：一個執行緒對主記憶體的修改可以及時被其他執行緒觀察到

因為這兩條規定，synchronized是具有可見性的
volatile可以保證變數的可見性，這兩條規則通俗來說，就是每當該變數被執行緒訪問時，都強迫從主記憶體中讀取變數。每當該變數被執行緒修改時，就強迫重新整理進主記憶體

@Slf4j
@NotThreadSafe
public class CountExample4 {

    public static int clientTotal = 5000;

    public static int threadTotal = 200;

    public static volatile int count = 0;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i = 0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}",count);
    }

    private static void add(){
        // 雖然這裡count變數被volatile修飾，是可見的，但依然沒有原子性，執行緒不安全
        // 當兩個執行緒同時操作count時，同時讀一個數，又同時重新整理進記憶體，依然會浪費一次操作
        count++;
    }
}

volatile的應用

雖然volatile修飾的變數時刻讀取都是他的真實值，因此特別適合用於作為標示量。
這裡執行緒1用作初始化，初始化成功則修改標誌量inited，而只有初始化成功後，才會執行執行緒2while內的內容

有序性

volatile可以保證一定的有序性
synchronized,lock保證了單執行緒的執行，因此肯定時有序的
java記憶體模型具有一些先天的有序性(不需要通過任何手段就能得到的有序性，即happens-before原則)

happens-before原則

happens-before規則如下：

程式順序規則：一個執行緒中的每個操作，happens- before 於該執行緒中的任意後續操作。
監視器鎖規則：對一個監視器鎖的解鎖，happens- before 於隨後對這個監視器鎖的加鎖。
volatile變數規則：對一個volatile域的寫，happens- before 於任意後續對這個volatile域的讀。
傳遞性：如果A happens- before B，且B happens- before C，那麼A happens- before C。
Thread.start()的呼叫會happens-before於啟動執行緒裡面的動作。
Thread中的所有動作都happens-before於其他執行緒從Thread.join中成功返回。

如果兩個操作執行的次序無法從happens-before原則中推匯出來，那麼就不能保證他們的有序性，jvm就可以隨意的對他們進行重排序

java多執行緒3：原子性，可見性，有序性
2020-04-23
Java執行緒
Java併發之原子性、有序性、可見性
2019-03-05
Java
三大性質總結：原子性、可見性以及有序性
2018-05-03
高階java必須清楚的概念：原子性、可見性、有序性
2018-05-02
Java
深入理解Java多執行緒與併發框（第③篇）——Java記憶體模型與原子性、可見性、有序性
2020-03-23
Java執行緒記憶體模型
理解併發程式設計的幾種"性" -- 可見性，有序性，原子性
2017-02-16
程式設計
執行緒安全性
2018-06-19
執行緒
Java併發程式設計Bug源頭：可見性、原子性和有序性問題
2019-04-11
Java程式設計
「跬步千里」詳解 Java 記憶體模型與原子性、可見性、有序性
2021-05-06
Java記憶體模型
二、執行緒安全性
2018-12-10
執行緒
走進volatile的世界，探索它與可見性，有序性，原子性之間的愛恨情仇！
2024-03-18
02. 執行緒安全性
2021-05-25
執行緒
可見性有序性，Happens-before來搞定
2019-09-17
APP
Java併發程式設計-併發程式設計的Bug源頭：可見性、原子性和有序性問題
2019-03-31
Java程式設計
執行緒安全性（第二章）
2017-12-01
執行緒
java安全編碼指南之:可見性和原子性
2020-09-25
Java
可重入性和執行緒安全
2017-11-12
執行緒
多執行緒的安全性問題（三）
2020-10-02
執行緒
JAVA 併發之路（二）執行緒安全性
2018-01-11
Java執行緒
Java中primitive type的執行緒安全性
2014-07-11
JavaMIT執行緒
【重學Java】多執行緒進階（執行緒池、原子性、併發工具類）
2021-07-16
Java執行緒
多執行緒安全性和Java中的鎖
2019-02-24
執行緒Java
深入解讀HashMap執行緒安全性問題
2019-03-13
HashMap執行緒
JCIP閱讀筆記之執行緒安全性
2019-01-19
筆記執行緒
執行緒安全性保證---JMM特性詳解
2020-10-19
執行緒
shared_ptr的執行緒安全性分析
2017-01-22
執行緒
併發程式設計之執行緒安全性
2016-03-07
程式設計執行緒
Java併發程式設計-解決可見性與有序性問題
2019-03-31
Java程式設計
你知道Java是如何解決可見性和有序性問題的嗎？
2021-04-22
Java
聊一聊Spring中的執行緒安全性
2017-11-06
Spring執行緒
記憶體可見性和原子性：Synchronized和Volatile的比較
2016-09-13
記憶體synchronized
探究Spring中Bean的執行緒安全性問題
2023-05-04
SpringBean執行緒
Java核心知識體系7：執行緒安全性討論
2023-11-28
Java執行緒
通過可見性逆轉物聯網安全性的7款工具
2018-05-23
10、Java併發性和多執行緒-執行緒安全與不可變性
2017-06-15
Java執行緒
記一次對Java多執行緒記憶體可見性的測試
2019-03-02
Java執行緒記憶體
volatile型變數語義講解一：對所有執行緒的可見性
2020-10-13
變數執行緒
淺談併發的資料競爭(可見性)與競態條件（原子性）
2018-09-23