AtomicInteger原理

目录

一、Integer与AtomicInteger测试

二、AtomicInteger源码分析

1. AtomicInteger源码

2. Unsafe源码

三、CAS的ABA问题

1. 什么是CAS

2. ABA问题

四、参考资料

---

一、Integer与AtomicInteger测试

package com.common.instance.test;

import org.junit.jupiter.api.Test;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @description 测试AtomicInteger
 * @author tcm
 * @version 1.0.0
 * @date 2021/10/29 16:19
 **/
public class TestAtomicInteger {

    private static int n = 0;
    private static AtomicInteger atomicInteger = new AtomicInteger(0);


    // 测试没有锁
    @Test
    public void testInteger() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            n = 0;
            Thread t1 = new Thread() {
                public void run() {
                    for(int i = 0; i < 10000; i++) {
                        n++;
                    }
                };
            };
            Thread t2 = new Thread() {
                public void run() {
                    for(int i = 0; i < 10000; i++) {
                        n++;
                    }
                };
            };
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(String.format("最终n%s的值为：%s", i, n));
        }

    }

    // 测试加锁
    @Test
    public void testAtomicInteger() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            atomicInteger = new AtomicInteger(0);
            Thread t1 = new Thread() {
                public void run() {
                    for(int i = 0; i < 10000; i++) {
                        atomicInteger.incrementAndGet();
                    }
                };
            };
            Thread t2 = new Thread() {
                public void run() {
                    for(int i = 0; i < 10000; i++) {
                        atomicInteger.incrementAndGet();
                    }
                };
            };
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(String.format("最终atomicInteger%s的值为：%s", i, atomicInteger));
        }
    }


}

// testInteger()运行结果
最终n0的值为：20000
最终n1的值为：15521
最终n2的值为：15366
最终n3的值为：15289
最终n4的值为：12855

// testAtomicInteger()运行结果
最终atomicInteger0的值为：20000
最终atomicInteger1的值为：20000
最终atomicInteger2的值为：20000
最终atomicInteger3的值为：20000
最终atomicInteger4的值为：20000

根据运行结果可以看出：Integer非原子操作，导致多线程运算结果不一定到20000；AtomicInteger原子操作，无论多线程运行几次都是20000。

二、AtomicInteger源码分析

1. AtomicInteger源码

package java.util.concurrent.atomic;

import java.util.function.IntUnaryOperator;
import java.util.function.IntBinaryOperator;
import sun.misc.Unsafe;

public class AtomicInteger extends Number implements java.io.Serializable {

    // Unsafe类: 使用native关键字，使Java拥有了像C语言的指针一样操作内存空间的能力；
    // Unsafe类在sun.misc包下，不属于Java标准，不建议使用
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

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

    // 使用volatile关键字
    private volatile int value;

    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    ......

    /**
     * 原子性设置值
     * @param expect 希望值，即：主内存变量的在当前线程的副本值
     * @param update 当前值
     * @return true，操作成功；false，表示希望值与实际值不符
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    ......


    // 当前值原子性加1
    public final int incrementAndGet() {
        // compareAndSwapInt操作
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

}

2. Unsafe源码

Unsafe的getAndAddInt，通过反编译可以看到实现代码（如下图所示）。compareAndSwapInt就是我们平时说的CAS(compare and swap)，在intel的CPU中，使用cmpxchg指令。

/*
 * 其中getIntVolatile和compareAndSwapInt都是native方法
 * getIntVolatile是获取当前的期望值
 * compareAndSwapInt就是我们平时说的CAS(compare and swap)，通过比较如果内存区的值没有改变，那么就用新值直接给该内存区赋值
 */
public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)
{
  int i;
  do
  {
    i = getIntVolatile(paramObject, paramLong);
  } while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));
  return i;
}

三、CAS的ABA问题

1. 什么是CAS

        CAS(compare and swap)，比较并交换。CAS操作包含三个操作数 —— 内存位置（V）、预期原值（A）、新值（B）。 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。在intel的CPU中，使用cmpxchg指令。

        类似CAS指令允许算法执行读-修改-写操作，而无需害怕其他线程同时修改变量，因为如果其他线程修改变量，那么CAS会检测它并失败，算法可以对该操作重新计算。

2. ABA问题

        ABA问题：CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却发生了变化。

        在JDK中提供了AtomicStampedReference类来解决这个问题。这个类也维护了一个int类型的标记stamp，每次更新数据的时候顺带更新一下stamp，即：除了要验证数据，还要验证时间戳。

四、参考资料

AtomicInteger原理 - scuwangjun - 博客园

Java中的Unsafe - 简书

全面理解Java内存模型_Heaven Wang 的专栏-CSDN博客_java内存模型

Java中CAS详解_jayxu无捷之径的博客-CSDN博客_cas

volatile和synchronized的区别_suchahaerkang的博客-CSDN博客