AtomicInteger如何实现原子增减

AtomicInteger 是 Java 并发包 java.util.concurrent.atomic 中的一个类，它提供了一种原子操作整数（int）的方式。原子操作意味着这些操作是不可分割的，即使在多线程环境下也不会出现数据不一致的问题。AtomicInteger 内部使用了底层的 Unsafe 类来实现原子性，以及 CAS（Compare-And-Swap）算法来保证操作的原子性。

以下是 AtomicInteger 实现原子增减的一些方法：

1. incrementAndGet()

这个方法会原子地将当前值加1，并返回增加后的值。

public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

2. decrementAndGet()

这个方法会原子地将当前值减1，并返回减少后的值。

public final int decrementAndGet() {
    for (;;) {
        int current = get();
        int next = current - 1;
        if (compareAndSet(current, next))
            return next;
    }
}

3. addAndGet(int delta)

这个方法会原子地将给定的增量（delta）加到当前值上，并返回增加后的值。

public final int addAndGet(int delta) {
    for (;;) {
        int current = get();
        int next = current + delta;
        if (compareAndSet(current, next))
            return next;
    }
}

4. getAndIncrement()

这个方法会原子地将当前值加1，但返回的是增加前的值。

public final int getAndIncrement() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return current;
    }
}

5. getAndDecrement()

这个方法会原子地将当前值减1，但返回的是减少前的值。

public final int getAndDecrement() {
    for (;;) {
        int current = get();
        int next = current - 1;
        if (compareAndSet(current, next))
            return current;
    }
}

6. getAndAdd(int delta)

这个方法会原子地将给定的增量（delta）加到当前值上，但返回的是增加前的值。

public final int getAndAdd(int delta) {
    for (;;) {
        int current = get();
        int next = current + delta;
        if (compareAndSet(current, next))
            return current;
    }
}

CAS（Compare-And-Swap）算法

CAS 是一种硬件级别的原子操作，它通过比较内存中的值和期望值来决定是否更新内存中的值。如果内存中的值等于期望值，则更新为新值；否则，不进行任何操作。AtomicInteger 使用 CAS 来实现原子性操作。

compareAndSet(int expect, int update)

这个方法会比较当前值是否等于期望值（expect），如果相等，则将当前值更新为新值（update），并返回 true；否则，返回 false。

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

通过这些方法和 CAS 算法，AtomicInteger 能够在多线程环境下安全地进行增减操作，避免了使用锁带来的性能开销。