（四）并发编程之CAS

小咪咪 2022-01-26 01:35 261阅读 0赞

# 原子类 #

**java.util.concurrent.atomic**包：原子类的小工具包，支持在单个变量上解除锁的线程安全编程。  
原子变量类相当于一种泛化的 volatile 变量，能够支持原子的和有条件的读-改-写操作。AtomicInteger 表示一个int类型的值，并提供了 get 和 set 方法，这些 Volatile 类型的int变量在读取和写入上有着相同的内存语义。它还提供了一个原子的 compareAndSet 方法（如果该方法成功执行，那么将实现与读取/写入一个 volatile 变量相同的内存效果），以及原子的添加、递增和递减等方法。AtomicInteger 表面上非常像一个扩展的 Counter 类，但在发生竞争的情况下能提供更高的可伸缩性，因为它直接利用了硬件对并发的支持。

*  为什么会有原子类  
    CAS：Compare and Swap，即比较再交换。  
    jdk5增加了并发包java.util.concurrent.\*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。
 *  如果同一个变量要被多个线程访问，则可以使用该包中的类  
    AtomicBoolean  
    AtomicInteger  
    AtomicLong  
    AtomicReference

public class CASDemo { 
        public static void main(String[] args) { 
            AtomicInteger atomicInteger = new AtomicInteger(5);
            System.out.println(atomicInteger.compareAndSet(5, 2019)+"\t current"+atomicInteger.get());
            System.out.println(atomicInteger.compareAndSet(5, 2014)+"\t current"+atomicInteger.get());
        }
    }

# CAS是什么？ #

CAS无锁机制  
CAS：Compare and Swap，即比较再交换。  
jdk5增加了并发包java.util.concurrent.\*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。

1.  与锁相比，使用比较交换（下文简称CAS）会使程序看起来更加复杂一些。但由于其非阻塞性，它对死锁问题天生免疫，并且，线程间的相互影响也远远比基于锁的方式要小。更为重要的是，使用无锁的方式完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，它要比基于锁的方式拥有更优越的性能。
2.  无锁的好处：  
    第一，在高并发的情况下，它比有锁的程序拥有更好的性能；  
    第二，它天生就是死锁免疫的。

就凭借这两个优势，就值得我们冒险尝试使用无锁的并发。

# CAS的底层原理是什么？ #

看atomicInteger.getAndIncrement();的源码可得

/** * Atomically increments by one the current value. * * @return the previous value */
    public final int getAndIncrement() { 
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

引出来一个问题:UnSafe类是什么?  
![在这里插入图片描述][20190527192622340.png]

1.  UnSafe  
    是CAS的核心类 由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问,UnSafe相当于一个后门,基于该类可以直接操作特额定的内存数据.**UnSafe类在于sun.misc包**中,其内部方法操作可以向C的指针一样直接操作内存,因为Java中CAS操作的执行依赖于UNSafe类的方法。  
    **注意UnSafe类中所有的方法都是native修饰的,也就是说UnSafe类中的方法都是直接调用操作底层资源执行响应的任务。**
2.  变量ValueOffset,便是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的  
    ![在这里插入图片描述][20190527193039602.png]  
    3.变量value和volatile修饰,保证了多线程之间的可见性。

# 再看CAS（分析底层原理） #

cas是什么？  
CAS的全称为Compare-And-Swap ,**它是一条CPU并发原语**。  
它的功能是判断内存某个位置的值是否为预期值,如果是则更新为新的值,这个过程是原子的。

CAS并发原语提现在Java语言中就是**sun.miscUnSaffe**类中的各个方法.调用UnSafe类中的CAS方法,JVM会帮我实现**CAS汇编指令**.这是一种完全依赖于硬件 功能,通过它实现了原子操作,再次强调,由于CAS是一种系统原语,原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,**并且原语的执行必须是连续的,在执行过程中不允许中断,也即是说CAS是一条原子指令,不会造成所谓的数据不一致的问题。**  
![在这里插入图片描述][20190527193705656.png]  
![在这里插入图片描述][20190527193727165.png]  
![在这里插入图片描述][20190527193740227.png]  
![在这里插入图片描述][20190527193921356.png]  
底层汇编：  
![在这里插入图片描述][20190527193848116.png]

# CAS的缺点 #

1.  循环时间长开销很大。  
    ![在这里插入图片描述][20190527194402391.png]
2.  只能保证一个共享变量的原子性。  
    ![在这里插入图片描述][20190527194430108.png]
3.  ABA问题（下面会说）

# 原子类AtomicInteger的ABA问题和原子更新引用 #

1.  ABA问题的产生  
    ![在这里插入图片描述][20190527194738251.png]
2.  原子引用的基本使用：

package com.bestqiang.thread;
    
    import java.util.concurrent.atomic.AtomicReference;
    
    /** * @author BestQiang */
    class User { 
        String username;
        int age;
    
        public String getUsername() { 
            return username;
        }
    
        public void setUsername(String username) { 
            this.username = username;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "username='" + username + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public User(String username, int age) { 
            this.username = username;
            this.age = age;
        }
    }
    public class ABADemo { 
        public static void main(String[] args) { 
            User u1 = new User("user1", 25);
            User u2 = new User("user2", 24);
            AtomicReference<User> atomicReference = new AtomicReference<>();
            atomicReference.set(u1);
            boolean b = atomicReference.compareAndSet(u1, u2);
            System.out.println(b);  // 输出结果为true，表示交换成功
        }
    }

1.  使用原子引用展示ABA问题和使用时间戳原子引用解决ABA问题：

package com.bestqiang.thread;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.concurrent.atomic.AtomicStampedReference;
    
    /** * @author BestQiang */
    public class ABA { 
        private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
        private static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 1);
    
        public static void main(String[] args) { 
            System.out.println("===以下是ABA问题的产生===");
            new Thread(() -> { 
                atomicReference.compareAndSet(100, 101);
                atomicReference.compareAndSet(101, 100);
            }, "t1").start();
    
            new Thread(() -> { 
                //先暂停1秒 保证完成ABA
                try { 
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get());
            }, "t2").start();
            try { 
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("===以下是ABA问题的解决===");
    
            new Thread(() -> { 
                int stamp = stampedReference.getStamp();
                System.out.println(Thread.currentThread().getName() + "\t 第1次版本号" + stamp + "\t值是" + stampedReference.getReference());
                //暂停1秒钟t3线程
                try { 
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                stampedReference.compareAndSet(100, 101, stampedReference.getStamp(), stampedReference.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + "\t 第2次版本号" + stampedReference.getStamp() + "\t值是" + stampedReference.getReference());
                stampedReference.compareAndSet(101, 100, stampedReference.getStamp(), stampedReference.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + "\t 第3次版本号" + stampedReference.getStamp() + "\t值是" + stampedReference.getReference());
            }, "t3").start();
    
            new Thread(() -> { 
                int stamp = stampedReference.getStamp();
                System.out.println(Thread.currentThread().getName() + "\t 第1次版本号" + stamp + "\t值是" + stampedReference.getReference());
                //保证线程3完成1次ABA
                try { 
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                boolean result = stampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
                System.out.println(Thread.currentThread().getName() + "\t 修改成功否" + result + "\t最新版本号" + stampedReference.getStamp());
                System.out.println("最新的值\t" + stampedReference.getReference());
            }, "t4").start();
        }
    }

输出结果如下：  
![在这里插入图片描述][20190527202422881.png]

[20190527192622340.png]: /images/20220126/5d6f91d38c944c3ba54e307e888e58fa.png
[20190527193039602.png]: /images/20220126/953412f3b552446393745cb5252b6563.png
[20190527193705656.png]: /images/20220126/53b5d68aea3143a6a55bf503f6699fc5.png
[20190527193727165.png]: /images/20220126/e66917da5be64ea3a702c728bfbdf9e6.png
[20190527193740227.png]: /images/20220126/7a2596f1bfcd4bb39754a61f685b2e86.png
[20190527193921356.png]: /images/20220126/1c99c1a56f5447b9b3d0049776001b47.png
[20190527193848116.png]: /images/20220126/426dd989d39b40f7b5db1189a829f8d7.png
[20190527194402391.png]: /images/20220126/83b818c0e1ec4fa8b7f2aab4ea5ffb6b.png
[20190527194430108.png]: /images/20220126/bf01c994edde4664ac4c10fbeab2d125.png
[20190527194738251.png]: /images/20220126/90e055ef7d584fbb82a211ba9cc2adf6.png
[20190527202422881.png]: /images/20220126/f8542ac251344a8d9c43e15d830d3cb5.png