首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >CAS 原子操作

CAS 原子操作

原创
作者头像
彼岸舞
修改2020-11-06 14:23:27
8060
修改2020-11-06 14:23:27
举报

理会CAS和CAS:

  有时候面试官面试问你的时候,会问,谈谈你对CAS的理解,这时应该有很多人,就会比较懵,当然,我也会比较懵,当然我和很多人的懵不同,很多人可能,并不知道CAS是一个什么东西,而在我看来我是不知道他问的是那个CAS

  我一般会问面试官,问他问的CAS是"原子操作",还是"单点登录"

  因为在JAVA并发中的原子操作是称为CAS的,也就是英文单词CompareAndSwap的缩写,中文意思是:比较并替换。

  但是在企业应用中CAS也被称为企业级开源单点登录解决方案,是 Central Authentication Service 的缩写 —— 中央认证服务,一种独立开放指令协议,是 Yale 大学发起的一个企业级开源项目,旨在为 Web 应用系统提供一种可靠的 SSO 解决方案。

CAS(Compare And Swap):

  我们先要学习的是并发编程中的CAS,也就是原子操作

  那么,什么是原子操作?如何实现原子操作?

什么是原子操作:

  原子,也是最小单位,是一个不可再分割的单位,不可被中断的一个或者一系列操作

  CAS是以一种无锁的方式实现并发控制,在实际情况下,同时操作一个对象的概率非常小,所以多数加锁操作做的基本是无用功

  CAS以一种乐观锁的方式实现并发控制

如何实现原子操作:

  Java可以通过锁和循环CAS的方式实现原子操作

为什么要有CAS:

  CAS就是比较并且替换的一个原子操作,在CPU的指令级别上进行保证

为什么要有CAS:

    Sync是基于阻塞的锁的机制,

      1:被阻塞的线程优先级很高

      2:拿到锁的线程一直不释放锁则么办

      3:大量的竞争,消耗CPU,同时带来死锁或者其他线程安全

    因为通过锁实现原子操作时,其他线程必须等待已经获得锁的线程运行完车之后才能获取锁,这样就会占用系统大量资源

CAS原理:

  从CPU指令级别保证这是一个原子操作

CAS包含哪些参数:

三个运算符:

    一个内存地址V

    一个期望的值A

    一个新值B

基本思路:

    如果地址V上的值和期望的值A相等,就给地址V赋值新值B,如果不是,不做任何操作

 循环CAS:

    在一个(死)循环中[for(;;)]里不断进行CAS操作,直到成功为止(自旋操作即死循环)

CAS问题:

ABA问题:

    那么什么是ABA问题?就是内存中原本是A,然后通过CAS变成了B,然后再次通过CAS变成了A,这个过程中,相对于结果来说,是没有任何改变的,但是相对于内存来说,至少发生过两次变化,这就是ABA问题

    生活中:

      就像你接了一杯水,这时水是满的,但是这个时候,你的同时很渴,过来拿你的水直接喝掉了一半,这时水剩下了一半,接着,你的同事又重新把你的水帮你接满了,那么这时你的水还是满的,相对于水来说,他还是满的,但是相对于杯子来说,他已经被用过了两次,一次是喝水,一次是接水,这就是ABA问题

    从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用,并且当前标志是否等于预期标志,如果全部相等,则以原子方式将该引用和该标志的值设置为给定的更新值。

    生活中:

      你接了一杯水,然后旁边放上一张登记表,这个时候你同事过来,直接喝掉了一半,然后登记上,XXX喝掉了一半的水,然后去给你接满了,再次登记上,我给你接满了,这时,ABA的问题就得到了解决,你一看这个表就知道了一切

开销问题:

    在自旋或者死循环中不断进行CAS操作,但是长期操作不成功,CPU不断的循环,带来的开销问题

    自旋CAS如果长时间不成功,会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升,pause指令有两个作用,第一它可以延迟流水线执行指令(de-pipeline),使CPU不会消耗过多的执行资源,延迟的时间取决于具体实现的版本,在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突(memory order violation)而引起CPU流水线被清空(CPU pipeline flush),从而提高CPU的执行效率。

  只能保证一个共享变量的原子操作

当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁,或者有一个取巧的办法,就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i=2,j=a,合并一下ij=2a,然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性,你可以把多个变量放在一个对象里来进行CAS操作。

CAS的目的:

利用CPU的CAS指令,同时借助JNI来完成Java的非阻塞算法。其它原子操作都是利用类似的特性完成的。而整个J.U.C都是建立在CAS之上的,因此对于synchronized阻塞算法,J.U.C在性能上有了很大的提升。

JDK中相关原子操作类的使用:

  更新基本类型类:AtomicBoolean,AtomicInteger,AtomicLong

  更新数组类:AtomicIntegerArray,AtomicLongArray,AtomicReferenceArrat

  更新引用类型:AtomicReference,AtomicMarkableReference,AtomicStampedReference

  原子更新字段类:AtomicReferenceFieldUpdater,AtomicIntegerFieldUpdater,AtomicLongFieldUpdater

理论已经理解的差不多了,接下来写写代码

使用AtomicInteger

package org.dance.day3;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用原子类int类型
 * @author ZYGisComputer
 */
public class UseAtomicInt {

    static AtomicInteger atomicInteger = new AtomicInteger(10);

    public static void main(String[] args) {
        // 10->11 10先去再增加
        System.out.println(atomicInteger.getAndIncrement());
        // 11->12 12先增加再取
        System.out.println(atomicInteger.incrementAndGet());
        // 获取
        System.out.println(atomicInteger.get());
    }

}

返回值:

10
12
12

通过返回值可以看到,第一个是先获取返回值后累加1,第二个是先累加1后再返回,第三个是获取当前值

使用AtomicIntegerArray

package org.dance.day3;

import java.util.concurrent.atomic.AtomicIntegerArray;

/**
 * 使用原子类int[]
 * @author ZYGisComputer
 */
public class UseAtomicIntegerArray {

    static int[] values = new int[]{1,2};

    static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(values);

    public static void main(String[] args) {
        //改变的第一个参数是 数组的下标,第二个是新值
        atomicIntegerArray.getAndSet(0,3);
        // 获取原子数组类中的下标为0的值
        System.out.println(atomicIntegerArray.get(0));
        // 获取源数组中下标为0的值
        System.out.println(values[0]);
    }

}

返回结果:

3
1

通过返回结果我们可以看到,源数组中的值并没有改变,只有引用中的值发生了改变,这是则么回事?

/**
     * Creates a new AtomicIntegerArray with the same length as, and
     * all elements copied from, the given array.
     *
     * @param array the array to copy elements from
     * @throws NullPointerException if array is null
     */
    public AtomicIntegerArray(int[] array) {
        // Visibility guaranteed by final field guarantees
        this.array = array.clone();
    }

通过看源码我们得知他是调用了数组的克隆方法,克隆了一个一模一样的

使用AtomicReference

package org.dance.day3;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 使用原子类引用类型
 * @author ZYGisComputer
 */
public class UseAtomicReference {

    static AtomicReference<UserInfo> atomicReference = new AtomicReference<>();

    public static void main(String[] args) {

        UserInfo src = new UserInfo("彼岸舞",18);

        // 使用原子引用类包装一下
        atomicReference.set(src);

        UserInfo target = new UserInfo("彼岸花",19);

        // 这里就是CAS改变了,这个应用类就好像一个容器也就是内存V,而src就是原值A,target就是新值B
        // 期望原值是src,如果是的话,改变为target,否则不变
        atomicReference.compareAndSet(src,target);

        System.out.println(atomicReference.get());

        System.out.println(src);

    }

    static class UserInfo{
        private String name;
        private int age;

        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

        public UserInfo() {
        }

        public UserInfo(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

}

返回结果:

UserInfo{name='彼岸花', age=19}
UserInfo{name='彼岸舞', age=18}

通过返回结果可以直观的看到,原子引用类中的值发生了改变,但是源对象src却没有改变,因为原子引用类和原对象本身是两个东西,CAS后就可以理解为内存中的东西变了,也可以说是引用变了,他只能保证你在改变这个引用的时候保证是原子性的

记得之前上面说的ABA问题吧,在这里就是解决代码

JDK中提供了两种解决ABA问题的类

  AtomicStampedReference

    AtomicStampedReference,里面是用int类型,他关心的是被人动过几次

  AtomicMarkableReference

    AtomicMarkableReference,里面是用boolean类型,他只关心这个版本有没有人动过

 两个类关心的点不一样,侧重的方向不一样,就像之前说的喝水问题,AtomicStampedReference关心的是,被几个人动过,而AtomicMarkableReference关心的是有没有人动过

使用AtomicStampedReference解决ABA问题

package org.dance.day3;

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 使用版本号解决ABA问题
 * @author ZYGisComputer
 */
public class UseAtomicStampedReference {

    /**
     * 构造参数地第一个是默认值,第二个就是版本号
     */
    static AtomicStampedReference<String> atomicStampedReference = new AtomicStampedReference<>("src",0);

    public static void main(String[] args) throws InterruptedException {

        // 获取初始版本号
        final int oldStamp = atomicStampedReference.getStamp();

        // 获取初始值
        final String oldValue = atomicStampedReference.getReference();

        System.out.println("oldValue:"+oldValue+" oldStamp:"+oldStamp);

        Thread success = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+",当前变量值:"+oldValue+"当前版本号:"+oldStamp);
                // 变更值和版本号
                /**
                 * 第一个参数:期望值
                 * 第二个参数:新值
                 * 第三个参数:期望版本号
                 * 第四个参数:新版本号
                 */
                boolean b = atomicStampedReference.compareAndSet(oldValue, oldValue + "java", oldStamp, oldStamp + 1);
                System.out.println(b);
            }
        });

        Thread error = new Thread(new Runnable() {
            @Override
            public void run() {
                // 获取原值
                String sz = atomicStampedReference.getReference();
                int stamp = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName()+",当前变量值:"+sz+"当前版本号:"+stamp);
                boolean b = atomicStampedReference.compareAndSet(oldValue, oldValue + "C", oldStamp, oldStamp + 1);
                System.out.println(b);
            }
        });

        success.start();
        success.join();
        error.start();
        error.join();
        System.out.println(atomicStampedReference.getReference()+":"+atomicStampedReference.getStamp());
    }

}

返回结果:

oldValue:src oldStamp:0
Thread-0,当前变量值:src当前版本号:0
true
Thread-1,当前变量值:srcjava当前版本号:1
false
srcjava:1

通过返回结果可以观察到,原始值是src,版本是0,然后使用join方法使我们的正确线程确保咋错误线程之前执行完毕,当正确线程执行完毕后,会把值改为srcjava,版本改为+1,然后执行错误的线程,错误的线程在尝试去改值的时候,发现期望的值是src,但是值已经被改变成srcjava了,并且期望的版本是0,但是版本已经被改为1了,所以他无法修改,在两个线程都执行完毕之后,打印的值是 srcjava,版本是1,成功的解决了ABA问题,当然在这里面我的期望值是还是src,也可以改为src+java但是因为版本不一样也是无法修改成功的;亲测没问题

原子更新字段类就不写了,那个使用比较麻烦,如果多个字段的话,就直接使用AtomicReference类就可以了

作者:彼岸舞

时间:2020\10\04

内容关于:并发编程

本文来源于网络,只做技术分享,一概不负任何责任

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 理会CAS和CAS:
    • CAS(Compare And Swap):
      • 什么是原子操作:
        • 如何实现原子操作:
          • 为什么要有CAS:
            • 为什么要有CAS:
          • CAS原理:
            • CAS包含哪些参数:
              • 三个运算符:
              • 基本思路:
              •  循环CAS:
            • CAS问题:
              • ABA问题:
              • 开销问题:
              •   只能保证一个共享变量的原子操作
            • JDK中相关原子操作类的使用:
              • 使用AtomicInteger
                • 使用AtomicIntegerArray
                  • 使用AtomicReference
                    • JDK中提供了两种解决ABA问题的类
                      • 使用AtomicStampedReference解决ABA问题
                  相关产品与服务
                  容器服务
                  腾讯云容器服务(Tencent Kubernetes Engine, TKE)基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务,覆盖 Serverless、边缘计算、分布式云等多种业务部署场景,业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者,主导开源项目Crane,全面助力客户实现资源优化、成本控制。
                  领券
                  问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档