亲宝软件园·资讯

展开

Java CAS原子操作详解

飞奔的小付 人气:0

一.什么是CAS

CAS(Compare And Swap,比较并交换),通常指的是这样一种原子操作:针对一个变量,首先比较它的内存值与某个期望值是否相同,如果相同,就给它赋一个新值。

二.流程

三.应用

在 Java 中,CAS 操作是由 Unsafe 类提供支持的,该类定义了三种针对不同类型变量的 CAS 操作

    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

它们都是 native 方法,由 Java 虚拟机提供具体实现,这意味着不同的 Java 虚拟机对它们的实现可能会略有不同。

以compareAndSwapInt为例,该方法提供四个参数,分别是:对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。

public class CASTest {
    public static void main(String[] args) {
        Entity entity = new Entity();
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");
        //12
        System.out.println(offset);
        boolean successful;
        // 4个参数分别是:对象实例、字段的内存偏移量、字段期望值、字段更新值
        //x是不是等于0,如果等于0就把它修改为3
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "-----" + entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "-----" + entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "-----" + entity.x);
    }
}
class Entity{
    int x;
}
public class UnsafeFactory {
    /**
     * 获取 Unsafe 对象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 获取字段的内存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
}

将x做了三次修改,执行结果是:

12

true-----3

true-----5

false-----5

四.源码解析

Hotspot 虚拟机对compareAndSwapInt 方法的实现如下:

#unsafe.cpp 
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jo bject obj, jlong offset, jint e, jint x)) 
UnsafeWrapper("Unsafe_CompareAndSwapInt"); 
oop p = JNIHandles::resolve(obj); 
// 根据偏移量,计算value的地址 
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
// Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值 e:要比较的值 
//cas成功,返回期望值e,等于e,此方法返回true 
//cas失败,返回内存中的value值,不等于e,此方法返回false 
return (jint)(Atomic::cmpxchg(x, addr, e)) == e; 
UNSAFE_END

核心逻辑在Atomic::cmpxchg方法中,这个根据不同操作系统和不同CPU会有不同的 实现。这里我们以linux_64x的为例,查看Atomic::cmpxchg的实现

#atomic_linux_x86.inline.hpp 
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint com pare_value) { 
 //判断当前执行环境是否为多处理器环境 
 int mp = os::is_MP(); 
 //LOCK_IF_MP(%4)在多处理器环境下,为cmpxchgl指令添加lock前缀,以达到内存屏障的效果 
  //cmpxchgl 指令是包含在 x86 架构及 IA‐64 架构中的一个原子条件指令, 
  //它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等, 
  //如果相等,则双向交换 dest 与 exchange_value,否则就单方面地将dest指向的内存值交给exchange_value。 
  //这条指令完成了整个CAS操作,因此它也被称为CAS指令。 
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)" 
  : "=a" (exchange_value) 
  : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp) 
  : "cc", "memory"); 
  return exchange_value; 
  }

需要注意的是cmpxchg有个隐含操作数eax,其实际过程是先比较eax的值(也就是 compare_value)和dest地址所存的值是否相等, 输出是"=a" (exchange_value),表示把eax中存的值写入exchange_value变量中。

Atomic::cmpxchg这个函数最终返回值是exchange_value,也就是说,如果cmpxchgl执行时compare_value和dest指针指向内存值相等则会使得dest指针指向内存值变成 exchange_value,最终eax存的compare_value赋值给了exchange_value变量,即函数最终返回的值是原先的compare_value。此时Unsafe_CompareAndSwapInt的返回值(jint) (Atomic::cmpxchg(x, addr, e)) == e就是true,表明CAS成功。如果cmpxchgl执行时 compare_value和(dest)不等则会把当前dest指针指向内存的值写入eax,最终输出时赋值给exchange_value变量作为返回值,导致(jint)(Atomic::cmpxchg(x, addr, e)) == e得到 false,表明CAS失败。

不管是 Hotspot 中的 Atomic::cmpxchg 方法,还是 Java 中的 compareAndSwapInt 方法,它 们本质上都是对相应平台的 CAS 指令的一层简单封装。CAS 指令作为一种硬件原语,有着天然 的原子性,这也正是 CAS 的价值所在。

五.缺点

CAS 虽然高效地解决了原子操作,但是还是存在一些缺陷的,主要表现在三个方面:

六.ABA 问题及解决方案

CAS算法实现一个重要前提需要取出内存中某时刻的数据,而在下时刻比较并替换,那么在这个时间差类会导致数据的变化。

当有多个线程对一个原子类进行操作的时候,某个线程在短时间内将原子类的值A修改为B,又马上将其修改为A,此时其他线程不感知,还是会修改成功。

代码演示

public class ABATest {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);
        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread1 read value: " + value);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通过CAS修改value值为3
            if (atomicInteger.compareAndSet(value, 3)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();
        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread2 read value: " + value);
            // Thread2通过CAS修改value值为2
            if (atomicInteger.compareAndSet(value, 2)) {
                log.debug("Thread2 update from " + value + " to 2");
                // do something
                value = atomicInteger.get();
                log.debug("Thread2 read value: " + value);
                // Thread2通过CAS修改value值为1
                if (atomicInteger.compareAndSet(value, 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

Thread1 read value: 1
Thread2 read value: 1
Thread2 update from 1 to 2
Thread2 read value: 2
Thread2 update from 2 to 1
Thread1 update from 1 to 3

Thread1以为值没有更新过,还是将1更新为了3

解决:

数据库有个锁称为乐观锁,是一种基于数据版本实现数据同步的机制,每次修改一次数据,版本就会进行累加。 同样,Java也提供了相应的原子引用类AtomicStampedReference。

public class AtomicStampedReference<V> {
    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }
    ...

stamp是版本,每次修改可以通过+1保证版本唯一性。这样 就可以保证每次修改后的版本也会往上递增。

public class AtomicStampedReferenceTest {
    public static void main(String[] args) {
        // 定义AtomicStampedReference    Pair.reference值为1, Pair.stamp为1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1,1);
        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread1 read value: " + value + ", stamp: " + stamp);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通过CAS修改value值为3   stamp是版本,每次修改可以通过+1保证版本唯一性
            if (atomicStampedReference.compareAndSet(value, 3,stamp,stamp+1)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();
        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int)atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread2 read value: " + value+ ", stamp: " + stamp);
            // Thread2通过CAS修改value值为2
            if (atomicStampedReference.compareAndSet(value, 2,stamp,stamp+1)) {
                log.debug("Thread2 update from " + value + " to 2");
                // do something
                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                log.debug("Thread2 read value: " + value+ ", stamp: " + stamp);
                // Thread2通过CAS修改value值为1
                if (atomicStampedReference.compareAndSet(value, 1,stamp,stamp+1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

Thread1 read value: 1, stamp: 1
Thread2 read value: 1, stamp: 1
Thread2 update from 1 to 2
Thread2 read value: 2, stamp: 2
Thread2 update from 2 to 1
Thread1 update fail!

因为版本不一样,Thread1没有将值修改成功,这就解决了ABA问题。

加载全部内容

相关教程
猜你喜欢
用户评论