前言

Java 并发编程系列番外篇C A S（Compare and swap），文章格调仍然是图文并茂，通俗易懂，让读者们也能与面试官疯狂对线。

C A S作为并发编程必不可少的基础知识，面试时 C A S 也是个高频考点，所以说 C A S 是必知必会，本文将带读者们深刻了解C A S。

纲要

C A S 基本概念

C A S（compareAndSwap）也叫比拟替换，是一种无锁原子算法，映射到操作系统就是一条 cmpxchg 硬件汇编指令（保障原子性 ），其作用是让C P U 将内存值更新为新值，然而有个条件，内存值必须与期望值雷同，并且 C A S 操作无需用户态与内核态切换，间接在用户态对内存进行读写操作（意味着不会阻塞 / 线程上下文切换）。

它蕴含 3 个参数 C A S（V，E，N），V 示意待更新的内存值，E示意预期值，N示意新值，当 V值等于 E 值时，才会将 V 值更新成 N 值，如果 V 值和 E 值不等，不做更新，这就是一次 C A S 的操作。

简略说，C A S须要你额定给出一个期望值，也就是你认为这个变量当初应该是什么样子的，如果变量不是你设想的那样，阐明它曾经被他人批改过了，你只须要从新读取，设置新期望值，再次尝试批改就好了。

C A S 如何保障原子性

原子性是指一个或者多个操作在 C P U 执行的过程中不被中断的个性，要么执行，要不执行，不能执行到一半（不可被中断的一个或一系列操作）。

为了保障 C A S 的原子性，C P U提供了上面两种形式

• 总线锁定
• 缓存锁定

总线锁定

总线（B U S）是计算机组件间的传输数据形式，也就是说 C P U 与其余组件连贯传输数据，就是靠总线实现的，比方 C P U 对内存的读写。

总线锁定 是指 C P U 应用了总线锁，所谓总线锁就是应用 C P U 提供的 LOCK# 信号，当 C P U 在总线上输入 LOCK# 信号时，其余 C P U 的总线申请将被阻塞。

缓存锁定

总线锁定形式尽管保障了原子性，然而在锁定期间，会导致大量阻塞，减少零碎的性能开销，所以古代 C P U 为了晋升性能，通过锁定范畴放大的思维设计出了缓存行锁定（缓存行是 C P U 高速缓存存储的最小单位）。

所谓 缓存锁定 是指 C P U 对缓存行 进行锁定，当缓存行中的共享变量回写到内存时，其余 C P U 会通过总线嗅探机制感知该共享变量是否发生变化，如果发生变化，让本人对应的共享变量缓存行生效，从新从内存读取最新的数据，缓存锁定是基于缓存一致性机制来实现的，因为缓存一致性机制会阻止两个以上 C P U 同时批改同一个共享变量（古代 C P U 根本都反对和应用缓存锁定机制）。

C A S 的问题

C A S和锁都解决了原子性问题，和锁相比没有阻塞、线程上下文你切换、死锁，所以 C A S 要比锁领有更优越的性能，然而 C A S 同样存在毛病。

C A S的问题如下

• 只能保障一个共享变量的原子操作
• 自旋工夫太长（建设在自旋锁的根底上）
• ABA问题

只能保障一个共享变量原子操作

C A S只能针对一个共享变量应用，如果多个共享变量就只能应用锁了，当然如果你有方法把多个变量整成一个变量，利用 C A S 也不错，例如读写锁中 state 的高下位。

自旋工夫太长

当一个线程获取锁时失败，不进行阻塞挂起，而是距离一段时间再次尝试获取，直到胜利为止，这种循环获取的机制被称为自旋锁(spinlock)。

自旋锁益处是，持有锁的线程在短时间内开释锁，那些期待竞争锁的线程就不需进入阻塞状态（无需线程上下文切换 / 无需用户态与内核态切换 ），它们只须要等一等（ 自旋），等到持有锁的线程开释锁之后即可获取，这样就防止了用户态和内核态的切换耗费。

自旋锁害处不言而喻，线程在长时间内持有锁，期待竞争锁的线程始终自旋，即 CPU 始终空转，资源节约在毫无意义的中央，所以个别会限度自旋次数。

最初来说自旋锁的实现，实现自旋锁能够基于 C A S 实现，先定义 lockValue 对象默认值 1，1 代表锁资源闲暇，0代表锁资源被占用，代码如下

public class SpinLock {
    
    //lockValue 默认值 1
    private AtomicInteger lockValue = new AtomicInteger(1);
    
    // 自旋获取锁
    public void lock(){

        // 循环检测尝试获取锁
        while (!tryLock()){// 空转}

    }
    
    // 获取锁
    public boolean tryLock(){
        // 期望值 1，更新值 0，更新胜利返回 true，更新失败返回 false
        return lockValue.compareAndSet(1,0);
    }
    
    // 开释锁
    public void unLock(){if(!lockValue.compareAndSet(1,0)){throw new RuntimeException("开释锁失败");
        }
    }

}

下面定义了 AtomicInteger 类型的 lockValue 变量，AtomicInteger是 Java 基于 C A S 实现的 Integer 原子操作类，还定义了 3 个函数lock、tryLock、unLock

tryLock 函数 - 获取锁

• 期望值 1，更新值 0
• C A S更新
• 如果期望值与 lockValue 值相等，则 lockValue 值更新为0，返回true，否则执行上面逻辑
• 如果期望值与 lockValue 值不相等，不做任何更新，返回false

unLock 函数 - 开释锁

• 期望值0，更新值1
• C A S更新
• 如果期望值与 lockValue 值相等，则 lockValue 值更新为1，返回true，否则执行上面逻辑
• 如果期望值与 lockValue 值不相等，不做任何更新，返回false

lock 函数 - 自旋获取锁

• 执行 tryLock 函数，返回 true 进行，否则始终循环

从上图能够看出，只有 tryLock 胜利的线程（把 lockValue 更新为 0），才会执行代码块，其余线程个tryLock 自旋期待 lockValue 被更新成 1，tryLock 胜利的线程执行 unLock（ 把lockValue更新为 1），自旋的线程才会tryLock 胜利。

ABA 问题

C A S须要查看待更新的内存值有没有被批改，如果没有则更新，然而存在这样一种状况，如果一个值原来是 A，变成了B，而后又变成了A，在C A S 查看的时候会发现没有被批改。

假如有两个线程，线程 1 读取到内存值 A，线程1 工夫片用完，切换到线程 2，线程2 也读取到了内存值 A，并把它批改为B 值，而后再把 B 值还原到 A 值，简略说，批改秩序是 A->B->A，接着线程1 复原运行，它发现内存值还是 A，而后执行C A S 操作，这就是驰名的 ABA 问题，然而如同又看不出什么问题。

只是简略的数据结构，的确不会有什么问题，如果是简单的数据结构可能就会有问题了（应用 AtomicReference 能够把 C A S 应用在对象上 ），以链表数据结构为例，两个线程通过C A S 去删除头节点，假如当初链表有 A->B 节点

• 线程 1 删除 A 节点，B节点成为头节点，正要执行 C A S(A,A,B) 时，工夫片用完，切换到线程2
• 线程 2 删除 A、B 节点
• 线程 2 退出 C、A 节点，链表节点变成A->C
• 线程 1 从新获取工夫片，执行C A S(A,A,B)
• 失落 C 节点

要解决 A B A 问题也非常简单，只有追加版本号即可，每次扭转时加 1，即A —> B —> A，变成1A —> 2B —> 3A，在Java 中提供了 AtomicStampedRdference 能够实现这个计划（面试只有问了C A S，就肯定会问ABA，这块肯定要搞明确）。

唠嗑唠嗑

C A S到这里就完结啦，当然了，后续会有 Atomic 系列的文章，有了 C A S 铺垫，前面的 Atomic 也是非常简略的，另外这里有个福利想告知下给各位读者，阿星公众号今天有个 回馈读者，送酷炫显示器一台的抽奖流动，还没关注的敌人们，能够提前关注啦，欢送大家参加，万一中了呢~

历史好文举荐

• 过程、线程与协程傻傻分不清？一文带你吃透！
• 什么是线程平安？一文带你深刻了解
• 小白也能看懂的 Java 内存模型
• 保姆级教学，22 张图揭开 ThreadLocal

对于我

这里是阿星，一个酷爱技术的 Java 程序猿，公众号 <span style=”color: Blue;”>「程序猿阿星」</span> 里将会定期分享操作系统、计算机网络、Java、分布式、数据库等精品原创文章，2021，与您在 Be Better 的路上独特成长！。

非常感谢各位小哥哥小姐姐们能看到这里，原创不易，文章有帮忙能够关注、点个赞、分享与评论，都是反对（莫要白嫖）！

愿你我都能奔赴在各自想去的路上，咱们下篇文章见