并发-CAS及其实现juc.atomic

关注

VIP免费原创 2025-09-27 06:57:00 445 阅读 AI 写同款· GEO 优化 ›

CAS原理和JUC原子类-1 JUC中多数类是通过volatile和CAS来实现的，CAS本质上提供的是一种无锁方案，而Synchronized和Lock是互斥锁方案。Java原子类本质上是使用CAS，而CAS底层是使用Unsafe类实现的，因此，想要学好JUC，必须要对CAS和底层的Unsafe原理彻底了解清楚。本篇文章通过流程图以及相关脑图等手段，力求能分析透彻。 CAS 阅读详情

什么是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代码在别的目录下面，没有粘贴，此处待优化

结果展示：