*java并发编程：3-原子操作CAS

*java并发编程：3-原子操作CAS

1，CAS（Compare And Swap）

什么是原子操作？如何实现原子操作？
乐观锁
JDK->CAS机制 --> 无锁化编程

1.1 CAS的原理：

• 利用了现代处理器都支持的CAS的指令，
• 循环这个指令，直到成功为止。
  

关键源码如下：
UnSafe 类 + CAS 思想（自旋）

AtomicInteger 的 getAndIncrement() 方法，底层使用的就是 CAS 的思想：

通过 unsafe 方法实现

this：当前对象
valueOffset：当前对象内存引用地址

1，从当前对象中取出当前值
2，和内存地址中的期望值进行比较，如果值一样递增 1 ，如果不一样继续从当前对象中取出最新值和当前对象内存中的值进行比较，知道修改成功为止。

1.2 CAS的问题：

• 1，如果 CAS 失败，会一直进行尝试，如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销。
• 2，只能保证一个共享变量的原子操作
• 3，引出 ABA 问题
  

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

2.1 更新基本类型：

• AtomicBoolean，AtomicInteger，AtomicLong
• 常用方法有：
  • getAndIncrement(); 先返回，再自增1
  • incrementAndGet(); 先自增1，再返回自增后的值

package com.h.concurrent.ch3;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author h
 * @Description 演示AtomicInteger 基本类型的原子操作类
 * @createTime 2020年03月23日 21:33
 */
public class UseAtomicInteger {

    static AtomicInteger ai = new AtomicInteger(10);

    public static void main(String[] args) {
        // 先获取当前值返回，然后再自增 1
        System.out.println(ai.getAndIncrement()); // 10
        // 先自增 1，然后再返回
        System.out.println(ai.incrementAndGet()); // 12
        // 在当前值的基础上，增加指定的值
        System.out.println(ai.addAndGet(24)); // 36

        // 对比期望值和当前值是否一致，如果一致则交换最新值并返回true，不一致不交换最新值并返回false
        boolean compareAndSet = ai.compareAndSet(10, 20);
        System.out.println(compareAndSet);
    }
}

2.2 更新数组类：

• AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray

package com.h.concurrent.ch3;

import java.util.concurrent.atomic.AtomicIntegerArray;

/**
 * @author h
 * @Description
 * @createTime 2020年03月23日 21:42
 */
public class UseAtomicArray {

    static int[] value = new int[]{1, 2};
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        int andSet = ai.getAndSet(0, 3);
        System.out.println("修改指定下标位置的值，并返回旧值：" + andSet);
        System.out.println("修改后的值：" + ai.get(0));
        System.out.println("修改 AtomicIntegerArray中的值，不会影响原数组的值：" + value[0]);
    }
}

2.3 更新引用类型：

• AtomicReference： 把多个变量封装成对象，达到可以修改多个变量的场景
• AtomicMarkableRefernce： 可以解决ABA问题
• AtomicStampedReference： 可有解决ABA问题

package com.h.concurrent.ch3;

import java.util.concurrent.atomic.AtomicReference;

/**
 * @author h
 * @Description 演示引用类型的原子操作类，通过把变量包装在对象中，可以达到支持修改多个变量的场景
 * @createTime 2020年03月23日 21:48
 */
public class UseAtomicReferrnce {

    static AtomicReference<UserInfo> atomicReference;

    public static void main(String[] args) {
        UserInfo zhangsan = new UserInfo("zhangsan", 18);
        atomicReference = new AtomicReference<UserInfo>(zhangsan);
        UserInfo lisi = new UserInfo("lisi", 19);

        boolean compareAndSet = atomicReference.compareAndSet(zhangsan, lisi);
        System.out.println(compareAndSet);
        System.out.println(atomicReference.get());
    }

    static class UserInfo{
        private volatile String name;
        private int age;
        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;
        }
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

2.4 原子更新字段类：

• AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater

package com.h.concurrent.ch3;

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author h
 * @Description 演示解决 ABA 问题
 * @createTime 2020年03月23日 21:58
 */
public class UseAtomicStampedReference {

    static AtomicStampedReference<String> stampedReference = new AtomicStampedReference<String>("init", 0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            int stamp = stampedReference.getStamp();
            boolean compareAndSet = stampedReference.compareAndSet("init", "t1Update", stamp, stamp + 1);
            System.out.println("t1 修改的结果为：" + compareAndSet);
        });

        Thread t2 = new Thread(() -> {
            int stamp = stampedReference.getStamp();
            boolean compareAndSet = stampedReference.compareAndSet("init", "t2Update", stamp, stamp + 1);
            System.out.println("t2 修改的结果为：" + compareAndSet);
        });

        t1.start();
        // 让线程1先执行完
        t1.join();

        t2.start();
        t2.join();

        System.out.println(stampedReference.getStamp() + " " + stampedReference.getReference());
    }
}

代码示例二：

```java
package com.test.thread.cas;

import lombok.experimental.var;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * Created by husz1 on 2019/12/23.
 */
public class ABADemo {

    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> atomicStampedReference = 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(() ->{
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println(Thread.currentThread().getName() +" "+ atomicReference.compareAndSet(100, 101) + "\t" + atomicReference.get());
        }, "t2").start();

        System.out.println("==============以下是ABA问题的解决===============");
        new Thread(() ->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号："+stamp);
            // 等待1秒钟，让t4线程拿到相同的版本号
            try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}
            atomicStampedReference.compareAndSet(100, 101, stamp, stamp+1);
            System.out.println(Thread.currentThread().getName() + "\t第2次版本号："+atomicStampedReference.getStamp());
            stamp = atomicStampedReference.getStamp();
            atomicStampedReference.compareAndSet(101, 100, stamp, stamp+1);
            System.out.println(Thread.currentThread().getName() + "\t第3次版本号："+atomicStampedReference.getStamp());
        }, "t3").start();

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号："+stamp);
            // 等待t3线程执行完毕
            try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
            boolean result = atomicStampedReference.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+" 打印成功否：" + result+" 实际版本号: "+ atomicStampedReference.getStamp() );
            System.out.println(Thread.currentThread().getName()+" 当前实际最新值：" + atomicStampedReference.getReference() + " result：" + result);
        }, "t4").start();

    }
}

打印的结果：

==============以下是ABA问题的产生===============
==============以下是ABA问题的解决===============
t3	第1次版本号：1
t4	第1次版本号：1
t2 true	101
t3	第2次版本号：2
t3	第3次版本号：3
t4 打印成功否：false 实际版本号: 3
t4 当前实际最新值：100 result：false