快捷導(dǎo)航

Java的原子類無鎖并發(fā)利器詳解

更新時(shí)間：2023年12月22日 09:34:21 作者：Java面試365

這篇文章主要介紹了Java的原子類無鎖并發(fā)利器詳解,原子類同樣能夠解決互斥性問題、原子性問題除此之外,因?yàn)樵宇愂菬o鎖操作,沒有用互斥鎖解決帶來的加鎖解決性能消耗,這種絕佳方案是怎么做到的呢,需要的朋友可以參考下

前言引入

當(dāng)存在如下場景，兩個(gè)線程同時(shí)去將count值累加一萬次，那么如下代碼是否存在線程安全問題呢？

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        TestCount testCount = new TestCount();
        Thread T1 = new Thread(()->{
            testCount.add10k();
        });
        Thread T2 = new Thread(()->{
            testCount.add10k();
        });
        T1.start();
        T2.start();
        T1.join();
        T2.join();
        System.out.println(testCount.count);
    }
}
class TestCount{
    long count = 0;
    void add10k(){
        int idx = 0;
        while (idx++ < 10000){
            count += 1;
        }
    }
}

顯然是存在的，最終的結(jié)果顯然是小于兩萬的，原因是count值存在可見性問題，count+=1也存在原子性的問題。

一般思路都是將count采用volatile修飾，count+=1原子性問題采用synchronized互斥鎖解決。

class TestCount{
    volatile long count = 0;
    synchronized void add10k(){
        int idx = 0;
        while (idx++ < 10000){
            count += 1;
        }
    }
}

但是對于這種簡單的互斥操作，需要采用synchronized這種比較重的互斥鎖嗎？有沒有更優(yōu)的解決辦法呢？當(dāng)然存在，采用原子類無鎖方案能夠極大的提升性能

class TestCount{
    AtomicLong count = new AtomicLong(0);
     void add10k(){
        int idx = 0;
        while (idx++ < 10000){
            count.getAndIncrement();
        }
    }
}

原子類同樣能夠解決互斥性問題、原子性問題除此之外，因?yàn)樵宇愂菬o鎖操作，沒有用互斥鎖解決帶來的加鎖解決性能消耗，這種絕佳方案是怎么做到的呢？

無鎖方案實(shí)現(xiàn)原理

無鎖方案之所以能夠保證原子性，主要還是硬件保證，CPU為了解決并發(fā)問題，提供了CAS（Compare And Swap）指令即比較并交換，CAS一般包含三個(gè)參數(shù)，共享變量的內(nèi)存地址A，用于比較的期望值B，更新共享變量C，當(dāng)共享變量的內(nèi)存地址A的值和共享變量B的值相等時(shí)，才將共享變量的內(nèi)存地址A處的值更新為共享變量C。

將場景語義化如下

class SimpleCAS{
    int count;
    public synchronized int cas(int expect,int newCount){
        // 讀取count值
       int oldcount = count;
       // 讀取的count值和期望值比較
       if (oldcount == expect){
           count = newCount;
       }
       // 返回老值
       return oldcount;
    }
}

CAS指令判斷并不是一次性的，如果比較失敗又會(huì)重新取最新的值和期望值判斷直到成功。

class SimpleCAS{
    volatile int count;
    public synchronized int cas(int expect,int newCount){
        // 讀取count值
       int oldcount = count;
       // 讀取的count值和期望值比較
       if (oldcount == expect){
            count = newCount;
        }
       // 返回老值
       return oldcount;
    }
    // 自旋操作，執(zhí)行cas方法
    public void addOne(){
        int newCount = 0;
        do {
            newCount = count + 1;
        }while (count != cas(count,newCount));
    }
}

ABA問題

原子類雖然好用，但是一定需要的坑就是ABA問題，假如存在共享變量A值為5，線程T1將共享變量A的值改為2，而線程T2將共享變量A改為3，線程T3又將共享變量A改為2，那么對于線程T1來講共享變量A是沒有變的嗎？顯然不是，可能大多數(shù)場景我們并不關(guān)心ABA問題，對于基礎(chǔ)數(shù)據(jù)遞增可能認(rèn)為值不變就夠了，并不關(guān)心值是否已經(jīng)修改，但是對于引用類型呢，這就一定要注意ABA問題，兩個(gè)A雖然相等，但是屬性可能已經(jīng)發(fā)生變化。

原子類提供工具類解決ABA問題AtomicStampedReference和AtomicMarkableReference

public static void main(String[] args) throws InterruptedException {
    // 初始化原子類 定義初始引用和標(biāo)識(shí)
    // AtomicMarkableReference同理可得，只是將版本戳換成了boolean類型
    AtomicStampedReference<String> reference = new AtomicStampedReference<>("zhangsan",1001);
    /**
      * expectedReference 期望的引用
      * newReference     新的引用
      * expectedStamp    期望的版本戳
      * newStamp         新的版本戳
      * 只有當(dāng)期望引用和期望版本戳都符合實(shí)際版本戳和引用才能替換成功
    */
    reference.compareAndSet("zhangsan","lisi",1002,1003);
    // zhangsan 替換失敗的原因是期望版本戳和實(shí)際版本戳不匹配
    System.out.println(reference.getReference());
    reference.compareAndSet("zhangsan","lisi",1001,1002);
    // lisi 替換成功
    System.out.println(reference.getReference());
    reference.compareAndSet("lisi1","wangwu",1002,1003);
    // lisi 替換失敗的原因是期望引用和實(shí)際引用不匹配
    System.out.println(reference.getReference());
}

getAndIncrement源碼分析

/**
  * this 指當(dāng)前對象
  * valueOffset 指內(nèi)存地址偏移量
*/
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
  * this 指當(dāng)前對象
  * valueOffset 指內(nèi)存地址偏移量
*/
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        // 就是讀取主內(nèi)存的值
        var5 = this.getIntVolatile(var1, var2);
        // this.compareAndSwapInt方法就是對應(yīng)上訴的cas方法，不過返回值是boolean類型
        // var5讀取的主內(nèi)存值
        // 更新成功返回true，跳出循環(huán)
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}