B8 Concurrent JDK中的乐观锁与原子类
【概述】
乐观锁采用的是一种无锁的思想，总是假设最好的情况，认为一个事务在读取数据的时候，不会有别的事务对数据进行修改，只需要在修改数据的时候判断原数据数据是否已经被修改了。JDK 中 java.util.concurrent.atomic 包下提供的原子类就是基于乐观锁的思想实现的，具体的实现主要依赖于 sun.misc.Unsafe 类提供的 CAS（Compare And Swap） 算法实现。
【CAS 算法】
Compare And Swap，顾名思义，先比较然后交换。CAS 算法主要的参数有三个：old（原值）、expect（期望值）、update（更新值）。首先比较 expect（期望值）与 old（原值）是否相等，若相等，则将 old（原值）更新为 update（更新值）。
JDK 1.8 中 sun.misc.Unsafe 类提供了以下几种 CAS 算法相关的方法
1） 最底层的方法（native method）：
public final native boolean compareAndSwapObject(Object paramObject1, long paramLong, Object paramObject2, Object paramObject3); public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2); public final native boolean compareAndSwapLong(Object paramObject, long paramLong1, long paramLong2, long paramLong3);
首先介绍一下这四个参数：
- 参数 1： 表示指向共享变量的引用
- 参数 2： 表示距离共享变量内存储存开始位置的偏移量，指向该变量对象的某一具体属性。obj + offset 可以确定 old（原值）
- 参数 3：表示 expect（期望值），用于与 old（原值）判断是否相等
- 参数 4：表示 update（更新值），若 expect 和 old 相等，则将 old 更新为 update
返回值：若 expect 与 old 判断相等，且将 old 更新为 update，则返回 true；否则返回 false。
2） JDK 1.8 新增方法：
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;
}
public final long getAndAddLong(Object paramObject, long paramLong1, long paramLong2)
{
long l;
do
l = getLongVolatile(paramObject, paramLong1);
while (!compareAndSwapLong(paramObject, paramLong1, l, l + paramLong2));
return l;
}
public final int getAndSetInt(Object paramObject, long paramLong, int paramInt)
{
int i;
do
i = getIntVolatile(paramObject, paramLong);
while (!compareAndSwapInt(paramObject, paramLong, i, paramInt));
return i;
}
public final long getAndSetLong(Object paramObject, long paramLong1, long paramLong2)
{
long l;
do
l = getLongVolatile(paramObject, paramLong1);
while (!compareAndSwapLong(paramObject, paramLong1, l, paramLong2));
return l;
}
public final Object getAndSetObject(Object paramObject1, long paramLong, Object paramObject2)
{
Object localObject;
do
localObject = getObjectVolatile(paramObject1, paramLong);
while (!compareAndSwapObject(paramObject1, paramLong, localObject, paramObject2));
return localObject;
}
对比 JDK 1.7 和 1.8 中原子类 AtomicInteger 的代码实现： JDK 1.8 将自旋操作封装到 sun.misc.Unsafe 类中
JDK1.7：
public final int getAndIncrement()
{
while (true)
{
int i = get();
int j = i + 1;
if (compareAndSet(i, j))
return i;
}
}
JDK 1.8：
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
【注意】
JDK 中乐观锁的实现思路：使用 volatile 关键字修饰共享变量 + sun.misc.Unsafe 类提供的 CAS 算法实现。volatile 关键字保证了线程的可见性，在进行 CAS 算法 “比较” 时，保证当前线程获取到的是最新的值；CAS 算法中 Compare （比较） 和 Swap（交换）是一组原子操作，保证了线程的原子性。
【CAS 与 ABA 问题】
ABA 问题指的是：一个线程将变量 A 修改为变量 B，然后又修改为变量 A，前后两个 A 可能修改了某些属性，已经发生了变更；另一个线程拿到仍然是变量 A，CAS 成功，但实际上另一线程拿到的变量 A可能已经被修改过的。
JDK 中提供了解决 ABA 问题的具体实现：java.util.concurrent.atomic.AtomicMarkableReference<V> 和 java.util.concurrent.atomic.AtomicStampedReference<V>。
【原子类 AtomicInteger 源码分析】
1). 初始化：定义了一个 volatile 关键字修饰的 int 变量 value，获取 Unsafe 对象和变量 value 的内存地址偏移量 valueOffset
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
/**
* Creates a new AtomicInteger with the given initial value.
*
* @param initialValue the initial value
*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/**
* Creates a new AtomicInteger with initial value {@code 0}.
*/
public AtomicInteger() {
}
2). 常用方法：使用 Unsafe 类的 CAS 算法实现
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
