CAS的原理
CAS(compare and swap)，即：比拟而后替换，运行程序如图：
- 三个运算符：一个内存地址V，一个期望值A，一个新值B。
- 基本思路：如果地址V上的值和期望值A相等，返回true，并给地址V赋上新值B，如果不是，返回false，不做任何操作。
- 循环(死循环，或者叫自旋)里一直的进行CAS操作。
古代处理器都反对CAS的指令，循环这个指令，直到胜利为止，蓝色局部是个原子操作，这个原子操作是计算机为咱们保障的，毋庸放心平安问题。
CAS所带来的问题
- ABA问题。
ABA问题就是假如某个内存地址上有一个数值A，但一个线程过去后把它变成了B，而后又变回了A，另一个线程过去后，发现内存地址上的值和冀望的值一样，故CAS胜利了，其实，内存地址上的值产生了变动，这种问题能够用加版本号的形式来解决。
- 零碎开销问题。
当一个CAS操作永远不胜利，它就会始终自旋，零碎开销微小，遇到这种状况，咱们只能应用syn锁或者其余锁的形式来代替CAS操作了。
- 只能保障一个共享变量的原子操作。
就是只可能保障一个共享变量，如果想保障多个变量的话，能够将这些变量放入一个援用变量中，atomic为咱们提供了操纵援用变量的类，叫AtomicReference
相干原子操作类
- 根本类型类：AtomicBoolean，AtomicInteger，AtomicLong
- 数组类：AtomicIntegerArray，AtomicLongArray
- 援用类型：AtomicReference，AtomicMarkableReference，AtomicStampedReference
- 原子更新字段类：AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater
AtomicInteger根本类型
public class Test { static AtomicInteger ai = new AtomicInteger(10); public static void main(String[] args) { // 相似"i++" System.out.println(ai.getAndIncrement()); // 相似"++i" System.out.println(ai.incrementAndGet()); System.out.println(ai.get()); // ----------减少指定数值-------------- //System.out.println(ai.addAndGet(10)); //System.out.println(ai.getAndAdd(10)); }}打印后果：
101212AtomicReference援用类型
public class Test { static AtomicReference<User> atomicReference = new AtomicReference(); public static void main(String[] args) { User user = new User("70KG", 18); // 要批改的实例 // 用之包装一下实体类对象 atomicReference.set(user); // 新对象 User newUser = new User("80KG", 20); // CAS操作 boolean flag = atomicReference.compareAndSet(user, newUser); // 要变动的实例 System.out.println(flag); // 打印包装类中的对象 System.out.println(atomicReference.get().getName()); System.out.println(atomicReference.get().getAge()); System.out.println("========================"); // 打印原对象 System.out.println(user.getName()); System.out.println(user.getAge()); } // 定义一个实体类 static class User { private String name; private int age; User(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } }}运行后果：
true80KG20========================70KG18剖析：
通过compareAndSet办法进行CAS操作，可见被包装过的user对象本值是不会发生变化的，扭转的只是包装的user对象，他们两个在被包装的时候就曾经不同了。
AtomicReference存在的问题
public class Test01 { // 申明援用值为0 static AtomicReference<Integer> atomicReference = new AtomicReference(0); public static void main(String[] args) throws InterruptedException { // 援用 final Integer reference = atomicReference.get(); // 原援用 System.out.println("reference初始值:" + reference); // 新起一个线程用来首次更改 Thread t1 = new Thread(new Runnable() { public void run() { Integer reference = atomicReference.get(); System.out.println(reference + "------" + atomicReference.compareAndSet(reference, reference + 10)); } }); // 改回原值 Thread t2 = new Thread(new Runnable() { public void run() { Integer reference = atomicReference.get(); System.out.println(reference + "------" + atomicReference.compareAndSet(reference, reference - 10)); } }); // 再做CAS Thread t3 = new Thread(new Runnable() { public void run() { Integer reference = atomicReference.get(); System.out.println(reference + "------" + atomicReference.compareAndSet(reference, reference + 10)); } }); // t1,t2,t3以此执行 t1.start(); t1.join(); t2.start(); t2.join(); t3.start(); t3.join(); System.out.println(atomicReference.get()); }}运行后果：
reference初始值:00------true10------true0------true10以上代码能够举个例子：
你倒了一杯水放桌子上，干了点别的事，而后共事把你水喝了又给你从新倒了一杯水，你回来看水还在，拿起来就喝，如果你不论水两头被人喝过，只关怀水还在，这就是ABA问题。下面代码就只关注后果没变就能够批改胜利，不关注过程。
AtomicStampedReference解决ABA问题
public class Test01 { // 申明援用值为0，版本号为0 static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference(0, 0); public static void main(String[] args) throws InterruptedException { // 原始版本号 final Integer initialStamp = atomicStampedReference.getStamp(); // 原始援用 final Integer initialReference = atomicStampedReference.getReference(); // 原援用和原版本号 System.out.println("reference初始值:" + initialReference + "版本号初始值:" + initialStamp); // 新起一个线程用来首次更改 Thread t1 = new Thread(new Runnable() { public void run() { System.out.println(initialReference + "-" + initialStamp + "-" + atomicStampedReference.compareAndSet(initialReference, initialReference + 10, initialStamp, initialStamp + 1)); } }); Thread t2 = new Thread(new Runnable() { public void run() { Integer stamp = atomicStampedReference.getStamp(); Integer reference = atomicStampedReference.getReference(); System.out.println(reference + "-" + stamp + "-" + atomicStampedReference.compareAndSet(reference, reference - 10, stamp, stamp + 1)); } }); Thread t3 = new Thread(new Runnable() { public void run() { // 取到以后援用值和版本号 Integer stamp = atomicStampedReference.getStamp(); Integer reference = atomicStampedReference.getReference(); System.out.println(reference + "-" + stamp + "-" + atomicStampedReference.compareAndSet(initialReference, reference + 10, initialStamp, stamp + 1)); } }); // t1,t2,t3程序执行 t1.start(); t1.join(); t2.start(); t2.join(); t3.start(); t3.join(); System.out.println(atomicStampedReference.getReference()); System.out.println(atomicStampedReference.getStamp()); }}运行后果：
reference初始值:0版本号初始值:00-0-true10-1-true0-0-false02剖析：
采纳AtomicStampedReference来解决ABA问题，t1线程批改了初始值，并将版本号加1，t2线程将值批改回了初始值，然而版本号加1，t3线程想要批改初始值，尽管以后值跟初始值相等，然而版本号还是用的原来的，故数据批改失败，解决了ABA问题。