深入掌握底层源码常见的 CAS 原子编程

static int NUM = 0;
public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10000; i++) {
        new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                NUM++;
            }
        }).start();
    }
    Thread.sleep(2000);
    System.out.println(NUM);
    /**
     * 99149419
     */
}

static int NUM = 0;
public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10000; i++) {
        new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                synchronized (Object.class) {
                    NUM++;
                }
            }
        }).start();
    }
    Thread.sleep(2000);
    System.out.println(NUM);
    /**
     * 100000000
     */
}

static AtomicInteger NUM = new AtomicInteger();
public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10000; i++) {
        new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
              	// 🚩 重点哦, 自增并获取新值
                NUM.incrementAndGet();
            }
        }).start();
    }
    Thread.sleep(2000);
    System.out.println(NUM);
    /**
     * 100000000
     */
}

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

// 获取Unsafe实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
// 静态代码块，在类加载时运行
static {
    try {
      	// 获取 value 的内存偏移量
        valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) {
        throw new Error(ex);
    }
}
private volatile int value;

// 获取当前 value 值
public final int get();
// 取当前的值, 并设置新的值
public final int getAndSet(int newValue);
// 获取当前的值, 并加上预期的值
public final int getAndAdd(int delta);
// 获取当前值, 并进行自增1
public final int getAndIncrement();
  
// 获取当前值, 并进行自减1
public final int getAndDecrement();

public final int getAndIncrement() {
  	return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
 * unsafe.getAndAddInt
 *
 * @param var1 AtomicInteger 对象
 * @param var2 value 内存偏移量
 * @param var4 增加的值, 比如在原有值上 + 1
 * @return
 */
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        // 内存中 value 最新值
        var5 = this.getIntVolatile(var1, var2);
    } while (!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

/**
 * 比较 var1 的 var2 内存偏移量处的值是否和 var4 相等, 相等则更新为 var5
 *
 * @param var1 AtomicInteger 对象
 * @param var2 value 内存偏移量
 * @param var4 value 原本的值
 * @param var5 期望将 value 设置的值
 * @return
 */
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

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

public static void main(String[] args) throws InterruptedException {
    AtomicInteger atomicInteger = new AtomicInteger(100);
    new Thread(() -> {
        atomicInteger.compareAndSet(100, 101);
        atomicInteger.compareAndSet(101, 100);
    }).start();
    Thread.sleep(1000);
    new Thread(() -> {
        boolean result = atomicInteger.compareAndSet(100, 101);
        System.out.println(String.format("  >>> 修改 atomicInteger :: %s ", result));
    }).start();
    /**
     *   >>> 修改 atomicInteger :: true 
     */
}

private static class Pair<T> {
  	// 存储值, 相当于上文的值100
    final T reference;
  	// 类似于版本号的概念
    final int stamp;
    private Pair(T reference, int stamp) {
        this.reference = reference;
        this.stamp = stamp;
    }
		// 创建一个新的Pair对象, 每次值变化时都会创建一个新的对象
    static <T> AtomicStampedReference.Pair<T> of(T reference, int stamp) {
        return new AtomicStampedReference.Pair<T>(reference, stamp);
    }
}

@SneakyThrows
public static void main(String[] args) {
    AtomicStampedReference stampedReference = new AtomicStampedReference(100, 0);
    new Thread(() -> {
        Thread.sleep(50);
        stampedReference.compareAndSet(100,
                101,
                stampedReference.getStamp(),
                stampedReference.getStamp() + 1);
        stampedReference.compareAndSet(101,
                100,
                stampedReference.getStamp(),
                stampedReference.getStamp() + 1);
    }).start();
    new Thread(() -> {
        int stamp = stampedReference.getStamp();
        Thread.sleep(500);
        boolean result = stampedReference.compareAndSet(100, 101, stamp, stamp + 1);
        System.out.println(String.format("  >>> 修改 stampedReference :: %s ", result));
    }).start();
  	/**
 			*   >>> 修改 atomicInteger :: false 
 			*/
}

/**
 * 比较并设置
 *
 * @param expectedReference 预期值
 * @param newReference      期望值
 * @param expectedStamp     预期版本号
 * @param newStamp          期望版本号
 * @return									是否成功
 */
public boolean compareAndSet(V expectedReference,
                             V newReference,
                             int expectedStamp,
                             int newStamp) {
    // 获取当前 pair 引用
    AtomicStampedReference.Pair<V> current = pair;
    // 预期值对比 pair value
    return expectedReference == current.reference &&
      			// 预期版本号对比 pair stamp
            expectedStamp == current.stamp &&
      			// 期望值对比 pair value
            ((newReference == current.reference &&
              			// 期望版本号对比 pair stamp
                    newStamp == current.stamp) ||
             				// casPair
                    casPair(current, Pair.of(newReference, newStamp)));
}

private boolean casPair(AtomicStampedReference.Pair<V> cmp, AtomicStampedReference.Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

Integer i1 = 100;
Integer i2 = 101;