CAS 原子操做

时间 2020-10-05

标签 java 面试算法编程数组安全网络并发 ide 性能栏目 Java 繁體版

原文原文链接

理会CAS和CAS:java

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

　　我通常会问面试官,问他问的CAS是"原子操做",仍是"单点登陆"算法

　　由于在JAVA并发中的原子操做是称为CAS的,也就是英文单词CompareAndSwap的缩写，中文意思是：比较并替换。编程

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

CAS(Compare And Swap):安全

　　咱们先要学习的是并发编程中的CAS,也就是原子操做网络

　　那么,什么是原子操做?如何实现原子操做?并发

什么是原子操做:ide

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

　　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

内容关于：并发编程

本文来源于网络，只作技术分享，一律不负任何责任