CAS基本原理
假定有两个操作A和B(A和B可能都很复杂)，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B，那么A和B对彼此来说是原子的。
实现原子操作可以使用锁，锁机制，满足基本的需求是没有问题的了，但是有的时候我们的需求并非这么简单，我们需要更有效，更加灵活的机制，synchronized关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程需要等待，直到该线程释放锁，
这里会有些问题：首先，如果被阻塞的线程优先级很高很重要怎么办？其次，如果获得锁的线程一直不释放锁怎么办？（这种情况是非常糟糕的）。还有一种情况，如果有大量的线程来竞争资源，那CPU将会花费大量的时间和资源来处理这些竞争，同时，还有可能出现一些例如死锁之类的情况，最后，其实锁机制是一种比较粗糙，粒度比较大的机制，相对于像计数器这样的需求有点儿过于笨重。
实现原子操作还可以使用当前的处理器基本都支持CAS()的指令，只不过每个厂家所实现的算法并不一样，每一个CAS操作过程都包含三个运算符：一个内存地址V，一个期望的值A和一个新值B，操作的时候如果这个地址上存放的值等于这个期望的值A，则将地址上的值赋为新值B，否则不做任何操作。
CAS的基本思路 就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事儿，但是要返回原值是多少。循环CAS就是在一个循环里不断的做cas操作，直到成功为止。
原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类。
美国化学会的下设组织化学文摘社（Chemical Abstracts Service,简称CAS）.该社负责为每一种出现在文献中的物质分配一个CAS编号,这是为了避免化学物质有多种名称的麻烦,使数据库的检索更为方便.
其缩写CAS在生物化学上便成为物质唯一识别码的代称,相当于每一种化学物质都拥有了自己的“学号“.如今的化学数据库普遍都可以用CAS编号检索.
CAS号是人对物质进行编号而来
参考： https://www.jianshu.com/p/ab2c8fce878b
https://www.jianshu.com/p/68f9cd012de8
CAS ：Compare and Swap，即比较再交换。
CAS算法理解 ：CAS是一种无锁算法，CAS有3个操作数，内存值E，旧的预期值V，要修改的新值N。当且仅当预期值V和内存值E相同时，将内存值E修改为N，否则什么都不做。
CAS算法图解 ：
上图描述了CAS的原理，以及带来的三大问题以及问题出现的位置。
1.ABA问题
因为CAS需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么CAS进行检查的时候发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面加上版本号，每次变量更新的时候把版本号加1，那么A->B->A就会变成1A->2B->3A。从Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前的标志是否等于预期标志，如果全部相等，则以原子方式将该应用和该标志的值设置为给定的更新值。
2.循环时间长开销大
自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销，如果JVM能支持处理器提供的pause指令，那么效率会有一定的提升。pause指令有两个作用：第一，它可以延迟流水线执行指令（de-pipeline），使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零；第二，它可以避免在循环的时候因内存顺序冲突（Memory Order Violation）而引起CPU流水线被清空，从而提高CPU的实行效率。
3.只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i=2,j=a,合并一下ji=2a,然后用CAS来操作ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之前的原子性，就可以把多个变量放在一个对象里来进行CAS操作。
CAS有三个操作数：内存值V、旧的预期值A、要修改的值B，当且仅当预期值A和内存值V相同时（条件），将内存值修改为B并返回true，否则条件不符合返回false。条件不符合说明该变量已经被其它线程更新。
cas优点：如一描述在并发量不是很高时cas机制会提高效率。
cas缺点：循环时间开销太大：如果CAS长时间执行不成功，则会给CPU带来交大的执行开销。处理器提供一种pause指令可以缓解这部分问题，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。
只能保证一个共享变量的原操作。如果需要对多个共享变量进行同步，就得使用锁，或者将几个共享变量封装起来，使用CAS来进行同步。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原性，你可以把多个变量放在一个对象里来进行CAS操作。
CAS号是指是美国化学文摘服务社为化学物质制订的登记号。
CAS英文“Chemical Abstracts Service”的简称，是指美国化学文摘服务社。CAS号是检索有多个名称的化学物质信息的重要工具，也是化合物、高分子材料、生物序列、混合物或合金的唯一的数字识别号码。CAS号是一种编号，现在每一种已经发现的化合物都有自己唯一对应的编号，就像身份证号一样。
发展历史和特点：
CAS编号最早出现于美国化学会的下设组织，化学文摘社出版的《化学摘要》里面，与其同时研发的网上检索系统一起配合，后来凭借无比的优越性，其他出版社也采用CAS编码来标明化学物质，现在海关化学物品进出口，也要用CZS编号来登记该资料。
美国化学会的下设组织化学文摘服务社负责为每一种出现在文献中的物质分配一个CAS号，其目的是为了避免化学物质有多种名称的麻烦，使数据库的检索更为方便。如今几乎所有的化学数据库都允许用CAS号检索。
CAS码来源于美国化学会的下设组织：化学文摘社（Chemical Abstracts Service，简称CAS）。该社负责为每一种出现在文献中的物质分配一个CAS编号，这是为了避免化学物质有多种名称的麻烦，使数据库的检索更为方便。其缩写CAS在化学上便成为化合物唯一识别码的代称，相当于每一种化合物都拥有了自己的身份证。
需要注意的是，同一化合物的不同水合物/无水物拥有不同的CAS号，但与试剂的级别没有关系，CAS号可以避免采购时因一物多名而带来的不必要的麻烦，也就是说你有必要建立一个名称-CAS号对应表，在采购时对一些特殊的试剂备注上CAS号，以避免采购错误或“采购不到”。
扩展资料：
化学试剂的分级：
通常按照国家标准的要求可以将化学试剂分为通用试剂、基准试剂和生物染色剂，而通用化学试剂分为化学纯、分析纯和优级纯，并要求其相应标签的主色调分别为中蓝色、金光红色和深绿色，基准试剂与优级纯试剂标签的颜色相同均为深绿色，生物染色剂为玫红色。
相应的，中国药典将试剂分为四种，基准试剂、化学纯、分析纯和优级纯，并明确了标定的基准物质为基准试剂，用于杂质限度检查用的标准溶液（例如氯化物、硫酸盐等），应采用优级纯或分析纯，其他检测和制备可以使用分析纯或化学纯试剂。
下面简单说一下cas编码的组成。由六位到九位的数字组成。其一般形式为【####aa-aa-a】。其中#表示可有可无的数字，a表示必须有的数字。也就是说最前面的数字位数是不一定的，有些物质是两位，最多可达六位。然而无论是什么化合物，必需至少有五位数组成。在原则上，数字大小可以反映物质发现的早晚，数字越大，表示发现得越晚。现在已有2000万余种物质有自己的cas编号。
cas编号最早出现于美国化学摘要服务社（chemical abstracts service，CAS即为该服务社的缩写)出版的《化学摘要》，与其同时研发的网上检索系统，后来凭借无比的优越性，其他出版社也采用cas编码来标明化学物质，现在海关化学物品进出口，也要登录该资料。
小伙伴们都知道，i++其实并非是原子性操作，在多线程环境下会有线程安全的问题，下面我们来写个测试demo来验证这条结论。
通过上面的小例子我们可以发现每次计算的结果都有偏差。为什么会存在偏差呢？这是因为JMM将内存分为工作内存+主内存。我们的运算工作是在工作内存中进行，然后再将得到的值同步到主内存中。
通过上图我们可以看到，一开始主内存中i=0，此时线程A把i读到工作内存，并开始进行i++的运算，然后把运算结果i=1同步给主内存。但是因为整个过程并不是原子性的（线程A运算的过程中，线程B也可以进行运算），这时候线程A还没有来得及把计算后的值刷新回主内存，线程B就开始进行了i++的操作，此时线程B拿到的i的值为0，而不是线程A计算后的1，这样线程B经过运算，得到的结果也是1，这样就导致最终结果是1而不是我们期望的2，从而造成线程安全问题。
1.synchronized锁
当我们对i++加了synchronized锁后，就可以保证它具有原子性，从而保证同一时刻只有一个线程能对i进行++操作，进而保证线程安全。
通过synchronized锁后，得到的结果跟预期结果相符。synchronized底层原理不是本篇文章的重点，后面会单出一篇文章来进行剖析。
2.通过J.U.C包下的AtomicInteger
ok,前面铺垫那么多，现在正式引入本文的重点： CAS ,AtomicInteger就是基于CAS技术实现的。
CAS，Compare and Swap即比较并替换。它是乐观锁思想的一种实现方式。
通过图我们可以看出CAS实现原理：CAS有三个操作数：内存值V、旧的预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做并返回false。
1.点开getAndIncrement()方法，我们会发现AtomicInteger调用了Unsafe的getAndInt()方法
小知识： JVM是规范，目前市面上主要有四种实现
1）Hotspot：最常用的jvm实现
2）JRocket：JRocket是BEA公司的JVM.使用WebLogic的用户,往往使用JRocket虚拟机.
3）J9：IBM公司的JVM
4）Harmony：IBM和Intel搞的开源JVM. IBM牵头,主力是Intel.
找到 atomic_linux_x86.inline.hpp ，找到cmpxchg方法
CAS是一种乐观锁，采用自旋的方式来等待其他线程完成工作。在竞争比较低且等待时间短的任务场景中表现优异。
1）因为CAS采用自旋方式，而自旋是需要占用CPU资源的。
2）只能保持一个变量的原子操作
3） ABA问题
这里我来给小伙伴解释下什么是ABA问题，还是拿CAS流程图来讲
前面我们也提到了，CAS虽然会占用CPU资源，但是只在用户态就可以完成加锁的过程（不需要涉及到内核态）。那么线程数较少，竞争不激烈，等待时间短的场景就是CAS的最佳适用场景。小伙伴们get到了吗？
public class CASDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(666)
// 获取真实值，并替换为相应的值
boolean b = atomicInteger.compareAndSet(666, 2019)
System.out.println(b)// true
boolean b1 = atomicInteger.compareAndSet(666, 2020)
System.out.println(b1)// false
atomicInteger.getAndIncrement()
}
}
CAS 底层原理？谈谈对 UnSafe 的理解？
getAndIncrement()
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1)
}
引出一个问题：UnSafe 类是什么？
UnSafe 类
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe()
private static final long valueOffset
static {
try {
// 获取下面 value 的地址偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"))
} catch (Exception ex) { throw new Error(ex)}
}
private volatile int value
// ...
}
Unsafe 是 CAS 的核心类，由于 Java 方法无法直接访问底层系统，而需要通过本地（native）方法来访问， Unsafe 类相当一个后门，基于该类可以直接操作特定内存的数据。Unsafe 类存在于 sun.misc 包中，其内部方法操作可以像 C 指针一样直接操作内存，因为 Java 中 CAS 操作执行依赖于 Unsafe 类。
变量 vauleOffset，表示该变量值在内存中的偏移量，因为 Unsafe 就是根据内存偏移量来获取数据的。
变量 value 用 volatile 修饰，保证了多线程之间的内存可见性。
CAS 是什么
CAS 的全称 Compare-And-Swap，它是一条 CPU 并发。
它的功能是判断内存某一个位置的值是否为预期，如果是则更改这个值，这个过程就是原子的。
CAS 并发原体现在 JAVA 语言中就是 sun.misc.Unsafe 类中的各个方法。调用 UnSafe 类中的 CAS 方法，JVM 会帮我们实现出 CAS 汇编指令。这是一种完全依赖硬件的功能，通过它实现了原子操作。由于 CAS 是一种系统源语，源语属于操作系统用语范畴，是由若干条指令组成，用于完成某一个功能的过程，并且原语的执行必须是连续的，在执行的过程中不允许被中断，也就是说 CAS 是一条原子指令，不会造成所谓的数据不一致的问题。
分析一下 getAndAddInt 这个方法
// unsafe.getAndAddInt
public final int getAndAddInt(Object obj, long valueOffset, long expected, int val) {
int temp
do {
temp = this.getIntVolatile(obj, valueOffset) // 获取快照值
} while (!this.compareAndSwap(obj, valueOffset, temp, temp + val)) // 如果此时 temp 没有被修改，就能退出循环，否则重新获取
return temp
}
CAS 的缺点？
循环时间长开销很大
如果 CAS 失败，会一直尝试，如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销（比如线程数很多，每次比较都是失败，就会一直循环），所以希望是线程数比较小的场景。
只能保证一个共享变量的原子操作
对于多个共享变量操作时，循环 CAS 就无法保证操作的原子性。
引出 ABA 问题
原子类 AtomicInteger 的 ABA 问题谈一谈？原子更新引用知道吗？
原子引用
public class AtomicReferenceDemo {
public static void main(String[] args) {
User cuzz = new User("cuzz", 18)
User faker = new User("faker", 20)
AtomicReference<User>atomicReference = new AtomicReference<>()
atomicReference.set(cuzz)
System.out.println(atomicReference.compareAndSet(cuzz, faker))// true
System.out.println(atomicReference.get())// User(userName=faker, age=20)
}
}
ABA 问题是怎么产生的
public class ABADemo {
private static AtomicReference<Integer>atomicReference = new AtomicReference<>(100)
public static void main(String[] args) {
new Thread(() ->{
atomicReference.compareAndSet(100, 101)
atomicReference.compareAndSet(101, 100)
}).start()
new Thread(() ->{
// 保证上面线程先执行
try {
Thread.sleep(1000)
} catch (InterruptedException e) {
e.printStackTrace()
}
atomicReference.compareAndSet(100, 2019)
System.out.println(atomicReference.get())// 2019
}).start()
}
}
当有一个值从 A 改为 B 又改为 A，这就是 ABA 问题。
时间戳原子引用
package com.cuzz.thread
import java.util.concurrent.atomic.AtomicReference
import java.util.concurrent.atomic.AtomicStampedReference
public class ABADemo2 {
private static AtomicStampedReference<Integer>atomicStampedReference = new AtomicStampedReference<>(100, 1)
public static void main(String[] args) {
new Thread(() ->{
int stamp = atomicStampedReference.getStamp()
System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp)
try {
Thread.sleep(1000)
} catch (InterruptedException e) {
e.printStackTrace()
}
atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 )
atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 )
}).start()
new Thread(() ->{
int stamp = atomicStampedReference.getStamp()
System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp)
try {
Thread.sleep(3000)
} catch (InterruptedException e) {
e.printStackTrace()
}
boolean b = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1)
System.out.println(b)// false
System.out.println(atomicStampedReference.getReference())// 100
}).start()
}
}
我们先保证两个线程的初始版本为一致，后面修改是由于版本不一样就会修改失败
