JUC-07-CAS

最新推荐文章于 2023-05-04 15:51:56 发布

彤彤的小跟班

最新推荐文章于 2023-05-04 15:51:56 发布

阅读量94

点赞数

分类专栏： JUC并发编程相关学习记录

本文链接：https://blog.csdn.net/weixin_45583303/article/details/119083479

版权

JUC并发编程相关学习记录专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章目录

CAS的引出

通过使用多线程修改一个变量来引出CAS

public class CASDemo02 {
    //定义一个变量
    public static int num=0;
    //一个执行加一操作的方法
    public static void numPlus() throws InterruptedException {
        //睡眠时间：每个线程过来调用这个方法就让它睡一会在执行加一操作，睡五毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        num++;
    }

    public static void main(String[] args) throws InterruptedException {
        //记录开始时间
        long startTime=System.currentTimeMillis();
        //我们要创建的线程数
        int threadSize=100;
        //使用栏栅类来控制
        CountDownLatch countDownLatch=new CountDownLatch(threadSize);
        for(int i=0;i<threadSize;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    //业务代码编写处：多线程改写一个变量的值
                    try {
                        //一个线程加十次，为的就是演示没有原子性
                        for(int j=0;j<10;j++){
                            //调用加一操作
                            numPlus();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }
                }
            });
            thread.start();
        }
        //通过栏栅类来控制，线程不创建完成，不能执行后面的代码
        //也就是，threadSize不减为0，不能越过栏栅
        countDownLatch.await();
        //结束时间
        long endTime=System.currentTimeMillis();
        //打印使用的时间，和线程的名字
        System.out.println(Thread.currentThread().getName()+"：耗时"+(endTime-startTime)+"  num="+num);
    }
}

运行结果

main：耗时65  num=907

分析：

时间很快，但是结果不正确
按道理来说，100个线程，每个线程对这个num修改10次，最后num的值应该是1000，但是结果却不是这样
Q：分析一下问题出在哪里？
A：num++操作实际上有三步来完成，所以numPlus这个方法没办法保证原子性
    1、获取num的值，记为A：A=num
    2、将A的值加一，得到B：B=A+1
    3、将B的值赋值给num

    如果有A和B两个线程，如果A执行到第一步被线程B抢占，线程B也执行了第一步，这时候等这两个线程都执行完
    这三步，num其实就加了一次，少加了一次

Q：怎么解决这个问题？
A：多线程的时候，只能让一个线程修改，一个线程不修改结束，其他线程不能进去修改，使用synchronized关键字
   对资源加锁

给操作资源的方法添加synchronized关键字

public synchronized static void numPlus() throws InterruptedException {
        //睡眠时间：每个线程过来调用这个方法就让它睡一会在执行加一操作，睡五毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        num++;
    }

运行结果

main：耗时5459  num=1000

分析

结果正确了，但是时间成本太高了，因为线程需要排队等待，耗时太长
synchronized关键字修饰的方法每次只允许一个线程来调用，其他线程要排队等待

Q：如何解决耗时的问题
A：num++操作实际上有三步来完成，所以numPlus这个方法没办法保证原子性
    1、获取num的值，记为A：A=num
    2、将A的值加一，得到B：B=A+1
    3、将B的值赋值给num
    我们使用另外一种方式实现
    	1、获取锁
    	2、获取count的最新值，记为newNum
    	3、判断执行的结果是否为newNum，如果是，返回true，不是返回false
    	4、释放锁
   	如果不是期望值，就返回继续获取num，循环执行。

问题出在加一操作的原子性，我们给加一操作这个代码进行改写，对加一操作进行加锁

public class CASDemo04 {
    //定义一个变量
    public volatile static int num=0;
    //一个执行加一操作的方法
    public static void numPlus() throws InterruptedException {
        //睡眠时间：每个线程过来调用这个方法就让它睡一会在执行加一操作，睡五毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        
        int newNum;//原始值
        //给加一操作这句代码加锁，保证加一操作的原子性，就不会有问题了
        while (!compareAndSwap(newNum=getNum(),newNum+1)){
            //不需要循环体
        }
    }

    //添加一个方法：用于比较新值与期望值是否相等
    public synchronized static boolean compareAndSwap(int newNum,int expectNum){
        //第二次获取num的值
        if(getNum()==newNum){
            num=expectNum;
            return true;
        }else {
            return false;
        }
    }

    public static int getNum() {
        return num;
    }

    public static void setNum(int num) {
        CASDemo04.num = num;
    }

    public static void main(String[] args) throws InterruptedException {
        //记录开始时间
        long startTime=System.currentTimeMillis();
        //我们要创建的线程数
        int threadSize=100;
        //使用栏栅类来控制
        CountDownLatch countDownLatch=new CountDownLatch(threadSize);
        for(int i=0;i<threadSize;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    //业务代码编写处：多线程改写一个变量的值
                    try {
                        //一个线程加十次，为的就是演示没有原子性
                        for(int j=0;j<10;j++){
                            //调用加一操作
                            numPlus();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }
                }
            });
            thread.start();
        }
        //通过栏栅类来控制，线程不创建完成，不能执行后面的代码
        //也就是，threadSize不减为0，不能越过栏栅
        countDownLatch.await();
        //结束时间
        long endTime=System.currentTimeMillis();
        //打印使用的时间，和线程的名字
        System.out.println(Thread.currentThread().getName()+"：耗时"+(endTime-startTime)+"  num="+num);
    }
}

运行结果：

main：耗时64  num=1000

分析

既保证了原子性，还保证了速度，其实我们写的那个compareAndSwap方法就是一个CAS

JDK对CAS的支持

CAS 全称：CompareAndSwap，比较且交换，什么意思那，看看定义
定义：

CAS包含三个操作数：内存位置（V），期望值（A），新值（B）
如果内存位置的值与期望值匹配，那么处理器会自动将该位置的值更新为新值，否则处理器不做任何操作，无论哪种情况，它都会在CAS指令之前返回该位置的值。
CAS在一些特殊情况下，仅返回CAS是否成功，而不提取当前值，CAS有效的说明了，我认为位置V应该包含值A，如果包含该值，则将B放到这个位置，否则不要更改该位置的值，只告诉我这个位置现在的值即可。

如何使用JDK提供的CAS

java中提供了对CAS的支持，具体的在sun.misc.unsafe类中

UnSafe：是CAS的核心类，由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问， UnSafe相当于一个后面，基于该类可以直接操作特定的内存数据。

注意：UnSafe类中所有的方法都是native修饰的,也就是说UnSafe类中的方法都是【直接调用操作底层资源执行响应的任务】

//比较并替换对象
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
//比较并替换整形
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
//比较并替换长整型
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

分析一下参数：

var1：表示要操作的对象
var2：表示要操作对象中属性地址的偏移量
var4：表示需要修改数据的期望值
var5：表示需要修改的新值

CAS实现的原理是什么

CAS通过调用JNI（java native interface）的代码实现，JNI允许java调用其他语言，而CompareAndSwapxxx系列的方法就是借助C语言来调用CPU底层指令实现的，最终由CPU执行指令实现比较并且交换的操作

注意：Java无法操作内存，需要通过本地方法利用C语言来操作内存

CAS存在的问题？

ABA问题

循环会耗时

一次性只能保证一个共享变量的原子性

什么是ABA问题？

CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，在CAS方法执行之前，被其他线程修改为B，然后又修改回了A，那么CAS方法执行检查的时候会发现它的值没有发生变化，但实际上发生了变化，这就是CAS的ABA问题。

演示CAS的ABA问题：

public class CASABADemo {
    //原子整形
    public static AtomicInteger a=new AtomicInteger(1);
    public static void main(String[] args) {
        Thread main=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("操作线程"+Thread.currentThread().getName()+"，初始值："+a.get());
                try {
                    int exceptNum=a.get();
                    int newNum=exceptNum+1;
                    //主线程休眠，让出CPU
                    Thread.sleep(1000);
                    //CAS操作
                    boolean isCasSuccess=a.compareAndSet(exceptNum,newNum);
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，CAS操作："+isCasSuccess);
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，CAS操作之后的值="+a.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"主线程");

        Thread other=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //先睡眠，保证main线程优先执行
                    Thread.sleep(20);
                    //执行加一操作
                    a.incrementAndGet();
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，increment，值="+a.get());
                    //执行减一操作
                    a.decrementAndGet();
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，increment，值="+a.get());

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"干扰线程");

        //启动线程
        main.start();
        other.start();
    }
}

运行结果

操作线程主线程，初始值：1
操作线程干扰线程，increment，值=2
操作线程干扰线程，increment，值=1
操作线程主线程，CAS操作：true
操作线程主线程，CAS操作之后的值=2

java中对ABA解决方法：AtomicStampedReference

java.util.concurrent.atomic.AtomicStampedReference：主要包含一个对象引用以及一个可以自动更新的整数stamp的pair对象来解决ABA问题。
如果想要更改数据，不仅要提供原来对象的引用，还要提供一个版本号（时间戳），只有这两个都对应上，才可以更改
看一下这个类的一个方法：compareAndSet

public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

参数分析

V   expectedReference：期望的引用
V   newReference：新引用
int expectedStamp：期望的版本号（时间戳）
int newStamp：新的版本号（时间戳）

演示解决ABA问题

/*注意：版本号只增不减*/
public class CSABADemo02 {
    //使用AtomicStampedReference
    public static AtomicStampedReference<Integer> a=new AtomicStampedReference<>(new Integer(1),1);

    public static void main(String[] args) {
        Thread main=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("操作线程"+Thread.currentThread().getName()+"，初始值："+a.getReference());
                try {
                    //获得期望的引用值
                    Integer exceptReference=a.getReference();
                    Integer newReference=exceptReference+1;
                    //获得期望的版本号
                    Integer expectStamp=a.getStamp();
                    Integer newStamp=a.getStamp()+1;

                    //主线程休眠，让出CPU
                    Thread.sleep(1000);
                    //CAS操作
                    boolean isCasSuccess=a.compareAndSet(exceptReference,newReference,expectStamp,newStamp);
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，CAS操作："+isCasSuccess);
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，CAS操作之后的值="+a.getReference());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"主线程");

        Thread other=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //先睡眠，保证main线程优先执行
                    Thread.sleep(20);
                    //执行加一操作
                    a.compareAndSet(a.getReference(),a.getReference()+1,a.getStamp(),a.getStamp()+1);
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，increment，值="+a.getReference());
                    //执行减一操作
                    a.compareAndSet(a.getReference(),a.getReference()-1,a.getStamp(),a.getStamp()+1);
                    System.out.println("操作线程"+Thread.currentThread().getName()+"，increment，值="+a.getReference());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"干扰线程");

        //启动线程
        main.start();
        other.start();
    }
}

运行结果

操作线程主线程，初始值：1
操作线程干扰线程，increment，值=2
操作线程干扰线程，increment，值=1
操作线程主线程，CAS操作：false
操作线程主线程，CAS操作之后的值=1

volatile和CAS和synchronized对比

volatile是java中的关键字，用于修饰变量，可以看做程度较轻的 synchronized

1、保证可见性
2、不保证原子性
3、禁止指令重排

CAS可以在一定程度上解决原子性的问题，但是无法消除ABA问题

其实CAS并没有真正的解决原子性的问题，就是因为ABA问题的存在，如果想真正的使用CAS解决原子性的问题，就要使用带时间戳的CAS。

synchronized可以解决上面的两种问题，但是执行速度会很慢

synchronized关键字相比于volatile关键字，不仅可以修饰变量，还可以修饰方法。

java.util.concurrent.atomic包

java中提供了自带CAS的类，在java.util.concurrent.atomic包里面，具体的可以自行查看
在这里插入图片描述
我们来看一下AtomicInteger这个类：

AtomicInteger.getAndIncrement()：方法
功能：加一操作

点进去看源码：底层是得到一个返回值，这个返回值由Unsafe类的getAndAddINT()方法提供

public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

- this：当前对象地址
- valueOffset：变量在内存中的偏移地址
- 1 ：整数1

点进去看一下unsafe类的getAndAddINT()方法：

public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
        	//通过对象地址和偏移地址获取对象的值并赋值给var5
            var5 = this.getIntVolatile(var1, var2);
            //再次通过对象地址和偏移地址获取对象的值，和var5比较，如果相同（没被修改），就让这个变量执行加一
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

代码演示：

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        System.out.println(atomicInteger.get());//获取构造的时候传入的值
        // 期望、更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语
        System.out.println(atomicInteger.compareAndSet(2020, 2021));//true
        System.out.println(atomicInteger.get());//看看是否更改
        atomicInteger.getAndIncrement();//加一操作
        System.out.println(atomicInteger.compareAndSet(2020, 2021));//false
        System.out.println(atomicInteger.get());//看看是否更改
    }
}

彤彤的小跟班

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JUC-07-CAS

文章目录CAS的引出JDK对CAS的支持java中对ABA解决方法：AtomicStampedReferencevolatile和CAS和synchronized对比java.util.concurrent.atomic包CAS的引出通过使用多线程修改一个变量来引出CASpublic class CASDemo02 { //定义一个变量 public static int num=0; //一个执行加一操作的方法 public static void numPlus
复制链接

扫一扫