Java CAS机制详解

什么是CAS机制

CAS（Compare And Swap），即比较并替换，是一种并发控制方式。它的思想是：当多个线程尝试同时更新某一个内存地址时，只有其中一个线程能更新成功，而其余的线程都需要等待。这种方式在并发编程中是很常见的。

CAS机制是通过硬件保证操作的原子性，来避免线程安全问题。

CAS操作的原理

CAS机制需要涉及到三个参数：内存地址V、旧的预期值A、新的值B。CAS机制被执行的时候，如果V的值是A，那么就把V的值更新为B，同时返回true。如果V的值不是A，说明已经被其他线程修改过，那么更新失败，返回false。

CAS的用法如下：

public boolean compareAndSet(int expectedValue, int newValue) {
    // 取得内存地址V的当前值
    int currentValue = get();

    // 如果V的值等于预期值A，就将V的值修改为B
    if (currentValue == expectedValue) {
        // 执行CAS操作，更新内存地址V的值为B
        set(newValue);

        // 返回true，表示更新成功
        return true;
    }

    // 如果V的值不等于预期值A，直接返回false，表示更新失败
    return false;
}

CAS与锁比较

CAS机制与锁机制相比较，有以下几个优势：

1. CAS操作不需要获取锁，因此它的开销小；
2. CAS操作在没有竞争的情况下，非常高效；
3. CAS操作是非阻塞的。

CAS的示例

以下是一个使用CAS实现线程安全计数器的示例：

public class CASCounter {
    private AtomicInteger count;

    public CASCounter() {
        this.count = new AtomicInteger(0);
    }

    public int getCount() {
        return count.get();
    }

    public void increment() {
        int oldValue = count.get();
        while (!count.compareAndSet(oldValue, oldValue + 1)) {
            oldValue = count.get();
        }
    }
}

该示例中，可以看到，使用CAS机制来实现计数器的自增操作。这种方式确保了计数器的线程安全，并且在高并发环境下的性能比使用同步锁要更好。

第二个示例是一个多线程实现的栈：

import java.util.concurrent.atomic.AtomicReference;

public class ConcurrentStack<E> {
    AtomicReference<Node<E>> top = new AtomicReference<Node<E>>();

    public void push(E item) {
        Node<E> newHead = new Node<>(item);

        while (true) {
            Node<E> oldHead = top.get();
            newHead.next = oldHead;
            if (top.compareAndSet(oldHead, newHead)) {
                return;
            }
        }
    }

    public E pop() {
        while (true) {
            Node<E> oldHead = top.get();
            if (oldHead == null) {
                return null;
            }
            Node<E> newHead = oldHead.next;
            if (top.compareAndSet(oldHead, newHead)) {
                return oldHead.item;
            }
        }
    }

    private static class Node<E> {
        public final E item;
        public Node<E> next;

        public Node(E item) {
            this.item = item;
        }
    }
}

该示例中，使用CAS机制来实现了栈的push和pop操作。在push操作中，首先获取栈顶节点，然后将新节点的next指向栈顶，使用compareAndSet方法来更新栈顶节点。在pop操作中，首先获取栈顶节点，然后将栈顶节点的next作为新的栈顶节点，并将栈顶节点的值作为返回值。如果栈为空或CAS操作失败，则重试。