AtomicInteger

最新推荐文章于 2022-12-09 10:59:55 发布

郝大侠001

最新推荐文章于 2022-12-09 10:59:55 发布

阅读量191

点赞数

分类专栏：高并发

本文链接：https://blog.csdn.net/jmkmlm123456/article/details/98371197

版权

高并发专栏收录该内容

20 篇文章 0 订阅

订阅专栏

引言

为什么AtomicInteger 不用加synchronized也能保证i++原子性；
因为用了CAS!!

1.CAS

a.概念

比较并交换（compareAndSet）

public class CASDemo {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);

        //main do thing ...

        System.out.println(atomicInteger.compareAndSet(5, 2019)+"\t current data:"+atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 1024)+"\t current data:"+atomicInteger.get());
    }
}

compareAndSet(expect,update) ;如果和current值一致，则设置为新的值；
========out
true	 current data:2019
false	 current data:2019

b.底层原理

JUC的原子类AtomicInteger底层使用的是CAS,来实现原子操作，借助atomicInteger.getAndIncrement()这个方法；

1.getAndIncrement()方法
//变量valueOffset，表示该变量在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的
//变量value用volatile修饰，保证了多线程之间的内存可见性。
public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
 //又引用了unsafe的getAndAddInt方法
--------------------->

2.UnSafe

Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地native方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。
Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。
注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务


public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
        //求偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

//只要一变化，volatile保证可见；
//变量value用volatile修饰，保证了多线程之间的内存可见性。
    private volatile int value;

接上一个方法！！

2.getAndAddInt()方法
//public native int getIntVolatile(Object var1, long var2);此方法为native方法
/*
*var1 线程对象，var2 初始值，var4 增加1
*/
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);//获取当前最新值
           //如果var2 var5相同，则原子性没问题
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

3.CAS底层思想

CAS的全称是Compare-And-Swap，它是一条CPU并发原语。
它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。
CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。
调用UnSafe类中CAS方法，JVM会帮我们实现CAS汇编指令。
这是一种完全依赖于硬件的功能，通过它实现原子小左。
再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干指令组成的，用语完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致性问题。

CAS（CompareAndSwap）
比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，
否则继续比较知道主内存和工作内存中的值一致为止。

CAS应用
CAS有3个操作数，内存之V，旧的预期值A，要修改的更新值B。
当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

getAndAddInt

假设线程A和线程B两个线程同时执行getAndAddInt操作（分别泡在不同CPU上）

1、AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。

2、线程A通过getIntVolatile（var1，var2）拿到value值3，这是线程A被挂起。

3、线程B也通过getIntVolatile（var1，var2）方法获得value值3，此时刚好线程B没有被挂起并执行compareAndSwap方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。

4、这是线程A回复，执行compareAndSwapInt方法比较，发现手里的值3与内存值4不一致，说明该值已经被其他线程抢险异步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了。

5、线程A重新获取value值，因为变量value被volatile修饰，所以其他线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，知道成功。

3.1 CAS缺点

do{—}while() 循环时间长开销大
只能保证一个共享变量的原子操作

当对一个共享变量执行操作时，我们只能使用循环CAS的方式来保证原子操作，但是，对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

引出来ABA问题？？？

4.ABA

a.概念

	狸猫换太子

b.产生

CAS会导致“ABA问题”。虽然比较前后值一样，但是中间过程可能发生了修改，不能保证是同一个线程操作的！！！！

CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。尽管线程one的CAS操作成功，但是不代表这个过程就是没问题的！！

c.原子引用依然产生ABA

AtomicReference 解决类对象原子

class User{
    String userName;
    int age;
    public User(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}
public class AtomicReferenceDemo {

    public static void main(String[] args) {
        User z3 = new User("z3",22);
        User li4 = new User("li4",25);

        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(z3);

        System.out.println(atomicReference.compareAndSet(z3, li4)+"\t"+atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4)+"\t"+atomicReference.get().toString());
    }
}
------out
true	User{userName='li4', age=25}
false	User{userName='li4', age=25}

4.1如何规避ABA问题

时间戳+原子引用!!!
JUC中AtomicStampedReference （初始值，时间戳）

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(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();

        new Thread(()->{
            //暂停1s,保证t1完成ABA
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get().toString());
        },"t2").start();

        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("======下面是ABA解决======");

        new Thread(()->{

            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号" + stamp);
            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() + "\t第2次版本号" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "\t第3次版本号" + atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(()->{

            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号" + stamp);
            //暂停3s,保证t3完成一次ABA操作
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            Boolean res = atomicStampedReference.compareAndSet(100,2019,stamp,stamp+1);
            System.out.println(Thread.currentThread().getName() + "\t修改成功否" + res + "当前版本号：" + atomicStampedReference.getStamp());
            System.out.println(Thread.currentThread().getName()+"\t当前实际最新值："+atomicStampedReference.getReference());

        },"t4").start();


    }
}
----------out
true	2019
======下面是ABA解决======
t3	第1次版本号1
t4	第1次版本号1
t3	第2次版本号2
t3	第3次版本号3
t4	修改成功否false当前版本号：3
t4	当前实际最新值：100

郝大侠001

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AtomicInteger

引言为什么AtomicInteger 不用加synchronized也能保证i++原子性；因为用了CAS!!1.CASa.概念比较并交换（compareAndSet）public class CASDemo { public static void main(String[] args) { AtomicInteger atomicInteger = new ...
复制链接

扫一扫