多线程之CAS和ABA

前言

　　文章主线

　　CAS -> UnSafe -> CAS底层思想 -> ABA -> 原子引用更新 -> 如何规避ABA问题

原理图

　　

　　CAS 最底层　　汇编与硬件

　　

(一) CAS  比较相等就修改    不相等就不修改 

　　为什么用CAS 不用synchronized （并发性不好，每次加锁操作完成后，才能进行下一步操作）

　　CAS 核心类 为Unsafe

　　由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，甚至该类可以直接操作特定内存的数据。

　　Unsafe类存在于sun.misc包中，其内部方法操作可以像C指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法

　　注意： Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应的任务

　　代码示例

package com.Interview.study.thread;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author zhangchaocai
 * @create 2020-04-16 13:40
 */
public class CASDemo {

    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(5);

        System.out.println( atomicInteger.compareAndSet(5,2020) + "	 current data : " + atomicInteger.get());

        //看了源码   compareAndSet 和 weakCompareAndSet 是一样的
        //底层都是   unsafe.compareAndSwapInt
        System.out.println( atomicInteger.weakCompareAndSet(2020,6666) + "	 current data : " + atomicInteger.get());

        System.out.println( atomicInteger.weakCompareAndSet(2020,77777) + "	 current data : " + atomicInteger.get());
    }
}

 　　运行结果

　　

　　CAS 缺点

　　例如 unSafe 中的getAndAddInt方法   中有个do while

　　

 　　如果CAS 失败，会一直尝试。如果CAS 长时间不成功，可能会给CPU带来很大的开销

---

 (二)  CAS 引出ABA  问题

　　ABA 释义  :   狸猫换太子

　　CAS 算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差之间会导致数据的变化。

　　比如说一个线程one从内存位置V取出A，这个时候另一个线程two也从内存中取出A，并且线程two进行进行了一些操作将值变味了B，

　　然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A,然后线程one操作成功

　　尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的

　　

　　解决ABA 问题   加版本号！！！（AtomicStampedReference）

package com.Interview.study.thread;

import java.sql.Time;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author zhangchaocai
 * @create 2020-04-16 13:35
 */
public class ABADemo { //ABA问题解决    AtomicStampedReference


    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);

    public static void main(String[] args) {

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "	第一次版本号:" + stamp);

            //T3线程暂停1秒
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "	第二次版本号:" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "	第三次版本号:" + atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "	第一次版本号:" + stamp);

            //T4线程暂停1秒
            try{
                TimeUnit.SECONDS.sleep(3);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            boolean result = atomicStampedReference.compareAndSet(100,2020,stamp,stamp+1);
            System.out.println(Thread.currentThread().getName() + "修改成功否:" + result);
            System.out.println(Thread.currentThread().getName() + "当前实际最新值:" + atomicStampedReference.getReference());
        },"t4").start();

    }

}

 运行结果

　　

---

　　     后来遇见他....