JUC包-原子类

JUC包-原子类

为什么需要JUC包中的原子类

首先，一个简单的i++可以分为三步：

读取i的值
计算i+1
将计算出i+1赋给i

这就无法保证i++的原子性，即在i++过程中，可能会出现其他线程也读取了i的

值，但读取到的不是更改过后的i的值。

原子类原理（AtomicInteger为例）

原子类的原子性是通过volatile + CAS实现原子操作的。

volatile

AtomicInteger类中的value是有volatile关键字修饰的，这就保证了value的内存可见性，这为后续的CAS实现提供了基础。

CAS

通过查看源码可以发现，AtomicInteger类的值更新操作都是通过调用

getAndAddInt(Object var1, long var2, int var4)方法实现

/**
* Atomically adds the given value to the current value.
*
* @param delta the value to add
* @return the previous value
*/
public final int getAndAdd(int delta) {
    //返回的是修改前的值，类似于i++
    return unsafe.getAndAddInt(this, valueOffset, delta);
}
/**
 * Atomically adds the given value to the current value.
 *
 * @param delta the value to add
 * @return the updated value
 */
public final int addAndGet(int delta) {
    //返回的是更新后的值,类似于++i
    return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

当我们查看getAndAddInt方法的具体实现，可以发现在整个方法中存在一个循

环，这就是我们说的自旋锁，顾名思义，while语句里面的条件一直为true，这个

循环就会一直执行下去。

public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        return var5;
    }

下面我们来分析getAndAddInt方法中的各个参数的具体含义：

Object var1：this，表示当前对象

long var2：valueOffset，表示当前对象的内存偏移量

int var4：delat，需要加上的数值

所以整个方法的运行流程可以归纳为：

读取传入对象this在主存中偏移量为offset位置的值赋值给var5
将var5的值与当前线程对象内存中偏移量为offset位置的值进行比较（compare）
如果相等，将var5+var4的值更新到对象内存中偏移量为offset位置（swap）；如果不

相等，就进入while循环自旋。

CAS的缺点

循环时间长，开销大

在并发量比较高的情况下，如果许多线程反复尝试更新某一个变量，却

又一直更新不成功，循环往复，会给CPU带来很大的压力
只能保证一个共享变量的原子性操作

CAS机制所保证的只是一个变量的原子性操作，而不能保证整个代码块

的原子性。比如需要保证3个变量共同进行原子性的更新，就不得不使用

Synchronized了
ABA问题

见下文

ABA问题

什么是ABA问题

简单来说就是CAS过程只在乎当前值与期望值是否相等，只在乎最终结果，不考虑中

间变化，具体可以看下面一个简单的例子。

public class Test {
    static AtomicInteger atomicInteger = new AtomicInteger(0);
    public static void main(String[] args) {
        atomicInteger.compareAndSet(0,1);
        System.out.println("线程A第一次修改：0->" + atomicInteger.get());
        new Thread(() -> {
            atomicInteger.compareAndSet(1,0);
            System.out.println("线程A第二次修改：1->" + atomicInteger.get());
        }, "testA").start();
        new Thread(() -> {
            try {
                //确保A线程修改完毕
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(0,2);
            System.out.println("线程B第一次修改：0->" + atomicInteger.get());
        }, "testB").start();
    }
}

程序运行后输出的结果，由此可见AtomicInteger的CAS中间步骤有变化，但是没有被感知到。

ABA问题的解决办法

一个简单的想法是，在数据上加上时间戳（版本号），使得线程每次对变量进行修改时，不仅要对比值，还要

对比时间戳（版本号），每次修改操作都会导致时间戳（版本号）改变为新的

值；

我们通过AtomicStampedReference类引入版本号，如下图所示

public class Test {
    //初始化数值为0，版本号为1
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(0, 1);
    public static void main(String[] args) {
        new Thread(() -> {
            /* compareAndSet四个参数分别为
             * 期望值/新的值/期望版本号/新的版本号
             */
            atomicStampedReference.compareAndSet(0, 1, 1, 2);
            System.out.println("数值第一次修改为" + atomicStampedReference.getReference() +
                    " 版本号第一次修改为" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(1, 0, 2, 3);
            System.out.println("数值第二次修改为" + atomicStampedReference.getReference() +
                    " 版本号第二次修改为" + atomicStampedReference.getStamp());
        }, "testA").start();
        new Thread(() -> {
            try {
                //确保A线程修改完毕
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(0, 1, 1, 2);
            System.out.println("数值第三次修改为" + atomicStampedReference.getReference() +
                        " 版本号第三次修改为" + atomicStampedReference.getStamp());
        }, "testB").start();
    }
}

上述代码的程序运行结果如下图所示，可以看到当第三次修改的时候，虽然期望值0匹配，但是期望版本号不匹配，导致第三次修改无效。