转载

Java并发 -- 原子类

private long count = 0;

public void add() {
    int idx = 0;
    while (idx++ < 10_000) {
        count += 1;
    }
}

add()方法不是线程安全的，主要原因是count的 可见性 和count+=1的 原子性
可见性的问题可以用 volatile 来解决，原子性的问题一般采用 互斥锁 来解决

无锁方案

private AtomicLong atomicCount = new AtomicLong(0);

public void atomicAdd() {
    int idx = 0;
    while (idx++ < 10_000) {
        atomicCount.getAndIncrement();
    }
}

无锁方案相对于互斥锁方案，最大的好处是性能
互斥锁方案为了保证互斥性，需要执行 加锁、解锁 操作，而加锁、解锁操作本身会消耗性能
- 拿不到锁的线程会进入阻塞状态，进而触发 线程切换 ，线程切换对性能的消耗也很大
无锁方案则完全没有加锁、解锁的性能消耗，同时能保证 互斥性

实现原理

CPU为了解决并发问题，提供了 CAS （Compare And Swap）指令
CAS指令包含三个参数：共享变量的内存地址A，用于比较的值B、共享变量的新值C
只有当内存地址A处的值等于B时，才能将内存地址A处的值更新为新值C
CAS指令是一条 CPU指令 ，本身能保 证原子性

自旋

public class SimulatedCAS {
    private volatile int count;

    public void addOne() {
        // 自旋
        int newValue;
        do {
            newValue = count + 1; // 1
        } while (count != cas(count, newValue)); // 2
    }

    // 模拟实现CAS
    private synchronized int cas(int expect, int newValue) {
        // 读取当前count的值
        int curValue = count;
        // 比较 当前count的值 是否等于 期望值
        if (curValue == expect) {
            count = newValue;
        }
        // 返回旧值
        return curValue;
    }
}

使用CAS解决并发问题，一般都会伴随着自旋（循环尝试）
首先计算newValue=count+1，如果count!=cas(count, newValue)
- 说明线程执行完代码1之后，在执行代码2之前，count的值被其他线程更新过，此时采用自旋（循环尝试）
通过 CAS+自旋 实现的无锁方案，完全没有加锁、解锁操作，不会阻塞线程，相对于互斥锁方案来说，性能提升了很多

ABA问题

上面的count==cas(count, newValue)，并不能说明执行完代码1之后，在执行代码2之前，count的值没有被其他线程更新过
假设count原本为A，线程T1在执行完代码1之后，执行代码2之前，线程T2将count更新为B，之后又被T3更新回A

count+=1 原子化

// AtomicLong
public final long getAndIncrement() {
    // this和valueOffset这两个参数可以唯一确定共享变量的内存地址
    return unsafe.getAndAddLong(this, valueOffset, 1L);
}

// Unsafe
public final long getAndAddLong(Object o, long offset, long delta) {
    long v;
    do {
        // 读取内存中的值
        v = getLongVolatile(o, offset);
    } while (!compareAndSwapLong(o, offset, v, v + delta));
    return v;
}

public native long getLongVolatile(Object o, long offset);

// 原子性地将变量更新为x，条件是内存中的值等于expected，更新成功则返回true
// compareAndSwapLong的语义和CAS指令的语义的差别，仅仅只是返回值不同而已
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);

原子类

Java并发 -- 原子类

原子化的基本类型

相关实现有AtomicBoolean、AtomicInteger和AtomicLong

getAndIncrement() // 原子化 i++
getAndDecrement() // 原子化的 i--
incrementAndGet() // 原子化的 ++i
decrementAndGet() // 原子化的 --i
// 当前值 +=delta，返回 += 前的值
getAndAdd(delta)
// 当前值 +=delta，返回 += 后的值
addAndGet(delta)
// CAS操作，返回是否成功
compareAndSet(expect, update)

// 以下四个方法
// 新值可以通过传入func函数来计算
getAndUpdate(func)
updateAndGet(func)
getAndAccumulate(x,func)
accumulateAndGet(x,func)

原子化的对象引用类型

相关实现有AtomicReference、AtomicStampedReference和AtomicMarkableReference，可以实现 对象引用的原子化更新
对象引用的更新需要重点关注 ABA问题 ，而 AtomicStampedReference 和 AtomicMarkableReference 可以解决ABA问题

AtomicStampedReference

public boolean compareAndSet(V   expectedReference,
                             V   newReference,
                             int expectedStamp,
                             int newStamp)

通过增加一个 版本号 即可解决ABA问题
每次执行CAS操作时，附加再更新一个版本号，只要保证版本号是递增的，即使A->B->A，版本号也不会回退

AtomicMarkableReference

将版本号简化成一个 Boolean值

public boolean compareAndSet(V       expectedReference,
                             V       newReference,
                             boolean expectedMark,
                             boolean newMark)

原子化的数组

相关实现有AtomicIntegerArray、AtomicLongArray和AtomicReferenceArray
利用这些原子类，可以原子化地更新数组里面的每一个元素

原子化的对象属性更新器

相关实现有AtomicIntegerFieldUpdater、AtomicLongFieldUpdater和AtomicReferenceFieldUpdater
利用这些原子类，都可以原子化地更新对象的属性，这三个方法都是利用 反射机制 实现的
对象属性必须是 volatile 类型，只有这样才能保证 可见性
- 如果对象属性不是volatile类型的，newUpdater会抛出IllegalArgumentException

// AtomicLongFieldUpdater
public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName);
// AtomicLongFieldUpdater#CASUpdater
public final boolean compareAndSet(T obj, long expect, long update)
// AtomicLongFieldUpdater#LockedUpdater
public final boolean compareAndSet(T obj, long expect, long update)