什么是CAS
CAS(compare and swap)的缩写，中文翻译成比较并交换,实现并发算法时常用到的一种技术。
它包含三个操作数——内存位置、预期原值及更新值。
执行CAS操作的时候，将内存位置的值与预期原值比较:如果相匹配，那么处理器会自动将该位置值更新为新值，如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功。
CAS原理
CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B。当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做或重试。它重试的这种行为称为自旋! 原理有点类似乐观锁，修改带版本号。
CAS是一条CPU的原子指令(cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchgo
CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。
它是非阻塞的且自身具有原子性，也就是说这玩意效率更高且通过硬件保证，说明它更可靠。
执行cmpxchg指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行cas操作，也就是说CAS的原子性实际上是CPU实现独占的，比起用synchronized重量级锁，这里的排他时间要短很多，所以在多线程情况下性能会比较好。
Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native)方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。
注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
compareAndSwapXXX
Atoniclnteger类主要利用CAS(compare and swap) + volatile和 native方法来保证原子操作，从而避免 synchronized的高开销，执行效率大为提升。
AtomicInteger的getAndIncrement()
1. public final int getAndIncrement() { 2. return unsafe.getAndAddInt(this, valueOffset, 1); 3. }
以原子方式递增当前值的 1。
返回：上一个值
CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。
1. public class Demo5 { 2. public static void main(String[] args) { 3. AtomicInteger atomicInteger=new AtomicInteger(3); 4. new Thread(() -> { 5. try { TimeUnit.MICROSECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } 6. int i = atomicInteger.getAndAdd(1); 7. System.out.println("A--->"+i); 8. 9. }, "A").start(); 10. new Thread(() -> { 11. int i = atomicInteger.getAndAdd(1); 12. System.out.println("B--->"+i); 13. }, "B").start(); 14. } 15. }
假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑在不同CPU上):AtomicInteger里面的value原始值为3，即主内存中AtomicIntegeri的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。线程A通过getIntVolatile(var1, var2)拿到value值3，这时线程A被挂起。线程B也通过getIntVolatile(var1, var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwaplnt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了。线程A重新获取value值，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。
1. public final int getAndAdd(int delta) { 2. return unsafe.getAndAddInt(this, valueOffset, delta); 3. }
以原子方式将给定值添加到当前值。
参数：增量 – 要添加的值
返回：上一个值
1. public final int getAndAddInt(Object o, long offset, int delta) { 2. int v; 3. do { 4. v = getIntVolatile(o, offset); 5. } while (!compareAndSwapInt(o, offset, v, v + delta)); 6. return v; 7. }
以原子方式将给定值添加到给定offset对象o中的字段或数组元素的当前值中。
参数：o – 用于更新字段/元素的对象/数组
偏移 – 字段/元素偏移
增量 – 要添加的值
返回：上一个值
CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。核心思想就是:比较要更新变量的值V和预期值E(compare)，相等才会将V的值设为新值N(swap）如果不相等自旋再来。
CAS与自旋锁
自旋锁(spinlock)，借鉴CAS思想
CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到锁的效果，至于自旋呢，看字面意思也很明白，自己旋转。是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU
CAS是实现自旋锁的基础，自旋翻译成人话就是循环，一般是用一个无限循环实现。这样一来，一个无限循环中，执行一个CAS操作，当操作成功返回 true 时，循环结束;当返回 false 时，接着执行循环，继续尝试CAS操作，直到返回true。
手写自旋锁
1. public class test { 2. AtomicReference<Thread> atomicReference=new AtomicReference<>(); 3. 4. public void lock(){ 5. Thread thread = Thread.currentThread(); 6. System.out.println(Thread.currentThread()+" come in ..."); 7. while (!atomicReference.compareAndSet(null, thread)) { 8. 9. } 10. } 11. 12. public void unLock(){ 13. Thread thread = Thread.currentThread(); 14. System.out.println(Thread.currentThread()+" over ..."); 15. atomicReference.compareAndSet(null,thread); 16. } 17. 18. public static void main(String[] args) { 19. SpinLockDemo spinLockDemo = new SpinLockDemo(); 20. new Thread(() -> { 21. spinLockDemo.lock(); 22. try { 23. TimeUnit.SECONDS.sleep(3); 24. } catch (InterruptedException e) { 25. e.printStackTrace(); 26. } 27. spinLockDemo.unLock(); 28. }, "A").start(); 29. try { 30. TimeUnit.SECONDS.sleep(1); 31. } catch (InterruptedException e) { 32. e.printStackTrace(); 33. } 34. new Thread(() -> { 35. spinLockDemo.lock(); 36. spinLockDemo.unLock(); 37. }, "B").start(); 38. } 39. }
CAS缺点
1）循环时间长开发很大
我们可以看到getAndAddint方法执行时，有个do while
1. public final int getAndAddInt(Object var1, long var2, int var4) { 2. int var5; 3. do { 4. var5 = this.getIntVolatile(var1, var2); 5. } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); 6. 7. return var5; 8. }
如果CAS失败，会一直进行尝试，如果CAS时间一直不成功，可能会给CPU带来很大的开销。
2）引出来ABA问题
ABA问题怎么产生的
比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变成了B，然后线程2又将V位置的数据变成A，这时候线程1进行CAS操作发现内存中仍然是A，预期OK，然后线程1操作成功。
CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。
尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的。
1. public static void aba() { 2. new Thread(()->{ 3. atomicInteger.compareAndSet(100,101); 4. try { 5. TimeUnit.MILLISECONDS.sleep(10); 6. } catch (InterruptedException e) { 7. e.printStackTrace(); 8. } 9. atomicInteger.compareAndSet(101,100); 10. },"t1").start(); 11. 12. new Thread(()->{ 13. try { 14. TimeUnit.MILLISECONDS.sleep(200); 15. } catch (InterruptedException e) { 16. e.printStackTrace(); 17. } 18. System.out.println(atomicInteger.compareAndSet(100,2022)+"\t"+atomicInteger.get()); 19. },"t2").start(); 20. }
怎么样解决
版本号时间戳原子引用
AtomicStampedReference类
1. import java.util.concurrent.atomic.AtomicStampedReference; 2. 3. class Book{ 4. int id ; 5. String bookName; 6. 7. public Book(int id, String bookName) { 8. this.id = id; 9. this.bookName = bookName; 10. } 11. 12. @Override 13. public String toString() { 14. return "Book{" + 15. "id=" + id + 16. ", bookName='" + bookName + '\'' + 17. '}'; 18. } 19. } 20. //带版本号的对象引用原子类 21. public class AtomicStampedDemo { 22. public static void main(String[] args) { 23. Book javaBook = new Book(1, "javaBook"); 24. AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook,1); 25. System.out.println(stampedReference.getReference()+"\t"+stampedReference.getStamp()); 26. Book mysqlBook = new Book(2, "mysqlBook"); 27. boolean b=stampedReference.compareAndSet(javaBook,mysqlBook,stampedReference.getStamp(),stampedReference.getStamp()+1); 28. System.out.println(b+"\t"+stampedReference.getReference()+"\t"+stampedReference.getStamp()); 29. 30. b = stampedReference.compareAndSet(mysqlBook, javaBook, stampedReference.getStamp(), stampedReference.getStamp() + 1); 31. 32. System.out.println(b+"\t"+stampedReference.getReference()+"\t"+stampedReference.getStamp()); 33. } 34. }
