Java 中的 CAS 机制详解

Java 中的 CAS 机制详解 | 极客日志

boolean cas(Object v, Object a, Object b) {
    if (v == a) {
        // 比较：当前值是否等于预期值
        v = b;
        // 交换：设置新值
        return true;
        // 成功
    } else {
        return false;
        // 失败
    }
}

import sun.misc.Unsafe;
import java.lang.reflect.Field;

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

    static {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);
            valueOffset = unsafe.objectFieldOffset(CASExample.class.getDeclaredField("value"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    // 自定义 CAS 操作
    public boolean compareAndSet(int expectedValue, int newValue) {
        return unsafe.compareAndSwapInt(this, valueOffset, expectedValue, newValue);
    }
}

类名	描述	常用方法
`AtomicInteger`	原子整型	`get()`, `set()`, `compareAndSet()`, `incrementAndGet()`
`AtomicLong`	原子长整型	`get()`, `addAndGet()`, `compareAndSet()`
`AtomicBoolean`	原子布尔型	`get()`, `compareAndSet()`
`AtomicReference<V>`	原子引用	`get()`, `set()`, `compareAndSet()`
`AtomicIntegerArray`	原子整型数组	`getAndSet()`, `compareAndSet()`
`AtomicStampedReference<V>`	带版本号的原子引用	解决 ABA 问题

import java.util.concurrent.atomic.AtomicInteger;

public class BasicCASExample {
    private AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = counter.get(); // 读取当前值
            newValue = oldValue + 1; // 计算新值
        } while (!counter.compareAndSet(oldValue, newValue)); // CAS 循环直到成功
    }

    public int getValue() {
        return counter.get();
    }

    public static void main(String[] args) throws InterruptedException {
        BasicCASExample example = new BasicCASExample();
        // 创建 10 个线程并发递增
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    example.increment();
                }
            });
            threads[i].start();
        }
        for (Thread t : threads) {
            t.join();
        }
        System.out.println("最终结果：" + example.getValue()); // 输出：10000
    }
}

import java.util.concurrent.atomic.AtomicReference;

public class ConcurrentStack<T> {
    private static class Node<T> {
        final T value;
        Node<T> next;

        Node(T value) {
            this.value = value;
        }
    }

    private AtomicReference<Node<T>> top = new AtomicReference<>();

    // 无锁 push 操作
    public void push(T value) {
        Node<T> newNode = new Node<>(value);
        Node<T> oldHead;
        do {
            oldHead = top.get(); // 读取当前栈顶
            newNode.next = oldHead; // 新节点指向旧栈顶
        } while (!top.compareAndSet(oldHead, newNode)); // CAS 更新栈顶
    }

    // 无锁 pop 操作
    public T pop() {
        Node<T> oldHead, newHead;
        do {
            oldHead = top.get(); // 读取当前栈顶
            if (oldHead == null) {
                return null; // 栈为空
            }
            newHead = oldHead.next; // 新栈顶为下一个节点
        } while (!top.compareAndSet(oldHead, newHead)); // CAS 更新栈顶
        return oldHead.value;
    }

    public boolean isEmpty() {
        return top.get() == null;
    }
}

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLock {
    private AtomicBoolean locked = new AtomicBoolean(false);

    public void lock() {
        // 自旋等待直到获取锁
        while (!locked.compareAndSet(false, true)) {
            // 可添加 Thread.yield() 或等待策略减少 CPU 占用
            Thread.yield();
        }
    }

    public void unlock() {
        locked.set(false);
    }

    public boolean tryLock() {
        return locked.compareAndSet(false, true);
    }
}

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABASolutionExample {
    public static void main(String[] args) {
        // 创建初始值，使用静态变量避免自动装箱创建新对象
        final Integer value100 = 100;
        final Integer value200 = 200;
        final Integer value300 = 300;

        // 初始值 100，版本号 0
        AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(value100, 0);
        int[] stampHolder = new int[1];
        int oldValue = ref.get(stampHolder);
        int oldStamp = stampHolder[0];
        System.out.println("初始：值=" + oldValue + ", 版本=" + oldStamp);

        // 模拟 ABA
        // ====================================================================
        // 注意：不能写成这样，否则 Integer 对象会被缓存，导致版本号不变
        // 步骤 1：100 → 200 ref.compareAndSet(100, 200, 0, 1); 这里的 100 和 200 都是自动装箱的 Integer 对象
        // 步骤 2：200 → 100 ref.compareAndSet(200, 100, 1, 2); 这里的 200 是新创建的 Integer 对象，与步骤 1 中的 200 不是同一个对象
        // ====================================================================

        // A -> B
        int[] stampHolder1 = new int[1];
        Integer currentValue1 = ref.get(stampHolder1);
        ref.compareAndSet(currentValue1, value200, stampHolder1[0], stampHolder1[0] + 1);

        // B -> A
        int[] stampHolder2 = new int[1];
        Integer currentValue2 = ref.get(stampHolder2);
        ref.compareAndSet(currentValue2, value100, stampHolder2[0], stampHolder2[0] + 1);

        // 尝试 CAS（会失败，因为版本变了）
        boolean success = ref.compareAndSet(oldValue, value300, oldStamp, oldStamp + 1);
        System.out.println("结果：" + (success ? "成功" : "失败"));
        System.out.println("原因：版本从" + oldStamp + "变为" + ref.getStamp());
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class CASvsLockBenchmark {
    private static final int THREAD_COUNT = 10;
    private static final int ITERATIONS = 1000000;

    // 测试方法
    private static long benchmark(Runnable task) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        Thread[] threads = new Thread[THREAD_COUNT];
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new Thread(() -> {
                task.run();
                latch.countDown();
            });
            threads[i].start();
        }
        latch.await();
        long end = System.currentTimeMillis();
        return end - start;
    }

    public static void main(String[] args) throws InterruptedException {
        // 1. 测试 synchronized
        Object lock = new Object();
        int[] syncCounter = {0};
        long syncTime = benchmark(() -> {
            for (int j = 0; j < ITERATIONS; j++) {
                synchronized (lock) {
                    syncCounter[0]++;
                }
            }
        });

        // 2. 测试 ReentrantLock
        ReentrantLock reentrantLock = new ReentrantLock();
        int[] lockCounter = {0};
        long lockTime = benchmark(() -> {
            for (int j = 0; j < ITERATIONS; j++) {
                reentrantLock.lock();
                try {
                    lockCounter[0]++;
                } finally {
                    reentrantLock.unlock();
                }
            }
        });

        // 3. 测试 CAS (AtomicInteger)
        AtomicInteger atomicCounter = new AtomicInteger(0);
        long atomicTime = benchmark(() -> {
            for (int j = 0; j < ITERATIONS; j++) {
                atomicCounter.incrementAndGet();
            }
        });

        System.out.println("测试结果（越低越好）:");
        System.out.println("synchronized: " + syncTime + "ms");
        System.out.println("ReentrantLock: " + lockTime + "ms");
        System.out.println("CAS (AtomicInteger): " + atomicTime + "ms");

        // 验证结果
        System.out.println("\n最终计数验证:");
        System.out.println("synchronized: " + syncCounter[0]);
        System.out.println("ReentrantLock: " + lockCounter[0]);
        System.out.println("CAS: " + atomicCounter.get());
    }
}

// ✅ 优先使用 JDK 提供的原子类
AtomicInteger counter = new AtomicInteger(0);
AtomicReference<User> userRef = new AtomicReference<>();

// ❌ 纯自旋，CPU 消耗大
while (!atomicRef.compareAndSet(oldValue, newValue)) {
    // 空循环
}

// ✅ 添加退避策略
int retries = 0;
while (!atomicRef.compareAndSet(oldValue, newValue)) {
    if (retries++ > 100) {
        Thread.yield();
    }
    // 或者使用指数退避
}

// 使用带版本号的原子引用
AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(0, 0);
// 或者使用 AtomicMarkableReference
AtomicMarkableReference<Integer> markedRef = new AtomicMarkableReference<>(0, false);

public void addIfLessThan(int max) {
    int current;
    int newValue;
    do {
        current = atomicInt.get();
        if (current >= max) {
            return; // 条件不满足
        }
        newValue = current + 1;
    } while (!atomicInt.compareAndSet(current, newValue));
}

Java 中的 CAS 机制详解

Java CAS（Compare And Swap）机制详解

一、概述

二、核心原理

1. 操作语义

2. 执行流程

3. 硬件支持

三、Java 中的 CAS 实现

1. sun.misc.Unsafe 类

2. java.util.concurrent.atomic 包

四、完整使用示例

示例 1：基础 CAS 操作

示例 2：实现线程安全的栈

示例 3：实现自旋锁

示例 4：带版本号的 CAS（解决 ABA 问题）

五、CAS 的优缺点

✅ 优点

❌ 缺点

六、CAS 与锁的性能对比

七、CAS 的适用场景

✅ 适合使用 CAS 的场景

❌ 不适合使用 CAS 的场景

八、最佳实践

1. 使用现有原子类

2. 避免过度自旋

3. 解决 ABA 问题

4. 组合操作使用循环 CAS

九、总结

更多推荐文章

相关免费在线工具

Java 中的 CAS 机制详解

Java CAS（Compare And Swap）机制详解

一、概述

二、核心原理

1. 操作语义

2. 执行流程

3. 硬件支持

三、Java 中的 CAS 实现

1. sun.misc.Unsafe 类

2. java.util.concurrent.atomic 包

四、完整使用示例

示例 1：基础 CAS 操作

示例 2：实现线程安全的栈

示例 3：实现自旋锁

示例 4：带版本号的 CAS（解决 ABA 问题）

五、CAS 的优缺点

✅ 优点

❌ 缺点

六、CAS 与锁的性能对比

七、CAS 的适用场景

✅ 适合使用 CAS 的场景

❌ 不适合使用 CAS 的场景

八、最佳实践

1. 使用现有原子类

2. 避免过度自旋

3. 解决 ABA 问题

4. 组合操作使用循环 CAS

九、总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具