理会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类就可以了