【JUC —— 14 CAS & Unsafe】

CAS（Compare-And-Swap）和 Unsafe 类是 Java 中实现无锁并发编程的两个重要概念。CAS 是一种原子操作，用于实现线程安全的变量更新，而 Unsafe 类提供了直接与底层硬件交互的方法，使得 CAS 操作得以实现。

CAS（Compare-And-Swap）

CAS 是一种用于实现原子操作的技术。它的核心思想是比较一个内存位置的当前值，如果该值与预期值相等，则更新为新值。这一过程是原子的，不会被其他线程打断。

CAS 的工作原理

CAS操作包含三个参数：

• V：需要更新的变量的内存地址。
• A：进行比较的预期值。
• B：需要更新的新值。

• 比较：将一个预期值与内存中的当前值进行比较。
• 交换：如果当前值与预期值相等，则将内存中的值更新为新值。
• 返回：返回操作是否成功的布尔值。

Unsafe 类

Unsafe 是 Java 中的一个类，提供了直接操作内存和线程的底层方法。因为它绕过了 Java 的安全检查和内存管理机制，所以被命名为 "Unsafe"。Unsafe 类的方法只能通过反射获取。

获取 Unsafe 实例

Unsafe 类的实例是通过反射获取的，因为它的构造方法是私有的，并且它的单例实例是一个私有静态字段。

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class UnsafeAccessor {
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            throw new RuntimeException("Unable to get Unsafe instance", e);
        }
    }
}

使用 Unsafe 实现 CAS

Unsafe 类提供了一些方法，如 compareAndSwapInt 和 compareAndSwapObject，用于实现 CAS 操作。这些方法直接调用底层硬件指令，实现原子操作。

示例：使用 Unsafe 实现 AtomicInteger

以下是一个使用 Unsafe 类实现的 AtomicInteger 示例：

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class AtomicInteger {
    private volatile int value;
    private static final Unsafe unsafe;
    private static final long valueOffset;

    static {
        try {
            // 获取 Unsafe 实例
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);

            // 获取 value 字段的偏移量
            valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }

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

    public int get() {
        return value;
    }

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

关键步骤解析

1. 获取 Unsafe 实例：

   Field field = Unsafe.class.getDeclaredField("theUnsafe");
   field.setAccessible(true);
   unsafe = (Unsafe) field.get(null);
   

   通过反射获取 Unsafe 类的实例。

2. 获取字段的内存偏移量：

   valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
   

   获取 value 字段在内存中的偏移量，这是 CAS 操作所需的参数之一。

3. 实现 compareAndSet 方法：

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

   使用 Unsafe 类的 compareAndSwapInt 方法执行 CAS 操作。

CAS 操作的优缺点

优点

1. 无锁并发：避免了使用传统锁机制，减少了上下文切换和锁竞争，提高了性能。
2. 简单高效：在大多数情况下，CAS 操作比锁更加高效，特别是在低竞争环境中。

缺点

1. ABA 问题：在极端情况下，一个值可能在多个线程操作期间变化并回到初始值，导致逻辑错误。可以通过版本号或标记来解决。
2. 自旋等待：在高竞争环境中，CAS 操作可能导致自旋等待，浪费 CPU 资源。

总结

CAS 和 Unsafe 是 Java 并发编程中实现无锁数据结构和算法的基础。CAS 通过硬件支持的原子操作确保数据的一致性，而 Unsafe 类提供了直接与底层硬件交互的方法，使得 CAS 操作得以实现。尽管 Unsafe 类的使用存在风险，但在高性能并发编程中，它是一个强大且不可或缺的工具。