并发-CAS及其实现juc.atomic

原创

已于 2025-09-27 06:57:00 修改 · 402 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2022-03-20 22:02:35 首次发布

本文详细介绍了CAS（CompareAndSwap）原理及其在多线程累加中的应用，对比了四种实现方式（volatile、synchronized、ReentrantLock和CAS Lock）的效率，并讨论了CAS的缺陷，如自旋开销和ABA问题。还提供了LongAdder和AtomicStampedReference的优化案例。

什么是CAS

CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首
先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。
CAS 的逻辑用伪代码描述如下：

 if (value == expectedValue) {
     value = newValue;
 }

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体
——一个不可分割的原子操作，并且其原子性是直接在硬件层面得到保障的。
CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操
作就通过CAS自旋实现的。
CAS是一种无锁算法，在不使用锁（没有线程被阻塞、上下文切换）的情况下实现多线程之间的变量同步。因此优先考虑使用CAS实现功能。

代码演示

10个线程同时，做100000以内的累加，如何实现？有几种方法？不同实现方式效率对比：

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

import com.test.jucdemo.lock.CASLock;

/**
 * @author
 */
public class Test {
    // 保证可见性
    private volatile static int sum = 0;
    static Object object = "";
    static ReentrantLock lock = new ReentrantLock();

    static CASLock casLock = new CASLock();

    /**
     * // 10个线程同时，做100000以内的累加，如何实现？  有几种方法？
     *
     * @param args
     */
    public static void main(String[] args) throws InterruptedException {
        test1();
        test2();
        test3();
        test4();
    }

    public static void test1() throws InterruptedException {
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    sum++;
                }
                countDownLatch.countDown();
            });
            thread.start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println(String.format("volatile sum : %s, 耗时：%s", sum, end - start));
        sum = 0;
    }

    public static void test2() throws InterruptedException {
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(10);
        Object object = "";
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    synchronized (object) {
                        sum++;
                    }
                }
                countDownLatch.countDown();
            });
            thread.start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println(String.format("synchronized sum : %s, 耗时：%s", sum, end - start));
        sum = 0;
    }


    public static void test3() throws InterruptedException {
        long start = System.currentTimeMillis();
        ReentrantLock lock = new ReentrantLock();
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                lock.lock();
                try {
                    for (int j = 0; j < 100000; j++) {
                        sum++;
                    }
                } finally {
                    countDownLatch.countDown();
                    lock.unlock();
                }
            });
            thread.start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println(String.format("ReentrantLock sum : %s, 耗时：%s", sum, end - start));
        sum = 0;
    }

    public static void test4() throws InterruptedException {
        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                // 自旋
                for (; ; ) {
                    //state=0
//                    System.out.println(casLock.getState());
                    if (casLock.getState() == 0 && casLock.cas()) {
                        try {
                            for (int j = 0; j < 100000; j++) {
                                sum++;
                            }
//                            System.out.println(casLock.getState());
                        } finally {
                            // state=0
                            casLock.setState(0);
                        }
                        break;
                    }
                }
                countDownLatch.countDown();
            });
            thread.start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println(String.format("casLock sum : %s, 耗时：%s", sum, end - start));
        sum = 0;
    }
}

CASLock代码在别的目录下面，没有粘贴，此处待优化

结果展示：