Java并发编程-CAS

千月落

已于 2023-07-01 16:18:59 修改

阅读量8.9k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java 文章标签：多线程 java 并发编程

于 2020-02-21 11:27:26 首次发布

本文链接：https://blog.youkuaiyun.com/yuanchengmm/article/details/104424767

Java 专栏收录该内容

20 篇文章

订阅专栏

文章目录

1.发现问题

我们先来看下面这样一段代码

	//定义一个静态成员变量i初始值为0
    private static Integer i = 0;
    
    public static void main(String[] args) throws InterruptedException {
        //启动子线程的数量
        int subThreadQuantity = 2;
        //外层for循环用于创建和启动子线程
        for (int j = 0; j < subThreadQuantity; j++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //内层循环用于对成员变量i自增10000次
                    for (int j = 0; j < 10000; j++) {
                        i++;
                    }
                }
            }).start();
        }
        //让主线程休眠5秒保证子线程能执行完
        Thread.sleep(5000);
        System.out.println("启动"+subThreadQuantity+"个子线程，分别对i自增10000次，i最终=" + i);

    }

我们运行这段代码5次，输出结果：

启动2个子线程，分别对i自增10000次，i最终=20000
启动2个子线程，分别对i自增10000次，i最终=13802
启动2个子线程，分别对i自增10000次，i最终=15728
启动2个子线程，分别对i自增10000次，i最终=10413
启动2个子线程，分别对i自增10000次，i最终=14679

我们来分析一下这段简单的代码，定义一个成员变量i初始化0，在main函数中启动2个线程，分别对i进行自增操作(i++)10000次。我们预期运行结果应该每次都是20000，但是每次执行的结果都不一样，不一定是20000。
这就是一个典型的非线程安全以及非原子操作的问题。

2.什么是原子性

原子的英文名(atom)是从希腊语转化而来，原意为不可切分的。很早以前，希腊和印度的哲学家就提出了原子的不可切分的概念，虽然后来证明原子并不是不能进一步切分的。但是一般人们习惯将原子性(atomicity)指代不可分割性，即原子性就是不可分割性。

3.什么是原子操作

原子操作就是具有原子性的操作：整个程序中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。
数据库事务,以及java内存模型中的操作都有这种特性。
现在我们来分析一下，上面那个问题。
在多核处理器中，假设我们启动的两个线程A 和B，线程A由CPU1执行，线程B由CPU2执行，由于变量i属于静态成员变量，被存储在静态区，由AB两个线程共享。
往往在分析问题的时候我们会忽略，for循环中，两个线程的私有变量j，这两个变量被存储各自线程私有的虚拟机栈内存里。我们现在对这两个变量命名，ja（A线程的j变量）和jb（B线程的j变量）。
我们模拟执行过程：

启动A线程后，A获得cpu1的时间片，cpu1从内存中把i的值取出来放到cpu1的寄存器中，此时i=0，同时也将A线程的私有变量ja放在了cpu1的寄存器中。
此时恰好线程B启动，B获得cpu2的时间片，cpu2从内存中把i的值取出来放到cpu2的寄存器中，此时也是i=0，同时也将B线程的私有变量jb放在了cpu2的寄存器中。
A线程：cpu1寄存器的i值+1，ja值+1 ,cpu1寄存器的i=1，ja=1。
A线程： cpu1寄存器的值写回内存,此时内存中i=1，ja=1。
B线程： cpu2寄存器的i值+1，jb值+1 ,cpu2寄存器的i=1，jb=1。
B线程： cpu2寄存器的值写回内存,此时内存中i=1，jb=1。

现在来看内存中三个变量的值 i=1 ,ja=1,jb=1 虽然两个处理器都去增加这个i，但最i的值只被加了1，其中一个线程加法运算“丢失”了，只做了一半的事情，只是把自己的私有变量增加了，并没有增加i的值，显然这个不是原子操作。
要解决这个问题，我们得让每个线程都实现原子操作。例如：我们从A线程来看，当另一个线程B执行时，要么将B全部执行完，要么完全不执行 B，那么 A 和 B 对彼此来说是原子的。
java中实现原子操作的方式有很多种，例如可以使用synchronized,该关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程需要等待，直到该线程释放锁。但是如果有大量的线程来竞争资源，那 CPU 将会花费大量的时间和资源来处理这些锁竞争，同时，还有可能出现一些例如死锁之类的情况。
所以今天我们使用当前的处理器基本都支持CAS机制，来实现原子操作，解决上面的问题。

4.CAS机制

CAS（ Compare And Swap ）就是比较并且交换的一个原子操作，由CPU在指令级别上进行保证,就是CPU在指令集上提供了 CAS 操作相关的指令，实现原子操作可以使用这些指令，只不过每个厂家所实现的算法并不一样，每一个 CAS 操作过程都包含三个运算符：一个内存地址 V，一个期望的值 A 和一个新值 B，操作的时候如果这个地址上存放的值等于这个期望的值 A，则将地址上的值赋为新值 B，否则不做任何操作。
CAS 的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事儿。循环 CAS 就是在一个循环里不断的做比较且交换（ Compare And Swap）操作，直到成功为止。
CAS是乐观锁的一种实现。
在这里插入图片描述

5.Java利用CAS机制实现原子操作

Java从JDK 1.5开始提供了java.util.concurrent.atomic包，这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。
因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型类、原子更新数组、原子更新引用类和原子更新属性类。Atomic包里的类基本都是使用Unsafe实现的，Unsafe通过调用底层硬件指令集来实现CAS操作。

1.原子更新基本类型

使用原子的方式更新基本类型，Atomic包提供了以下3个类。
AtomicBoolean：原子更新布尔类型。
AtomicInteger：原子更新整型。
AtomicLong：原子更新长整型。

以上3个类提供的方法几乎一模一样，AtomicInteger的常用方法如下。

AtomicInteger的常用方法有：

 1.以原子的方式将输入的值与实例中的值相加，并把结果返回	
public final int addAndGet(int delta)

 2.如果输入值等于预期值，以原子的方式将该值设置为输入的值
 public final boolean compareAndSet(int expect, int update)

 3.以原子的方式将当前值加1，并返回加1之前的值 类似于 i++
 public final int getAndIncrement()

 4.以原子的方式将当前值设置为newValue,并返回设置之前的旧值
 public final int getAndSet(int newValue)

 5.最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
 public final void lazySet(int newValue)

2.原子更新数组

atomic里提供了三个类用于原子更新数组里面的元素，分别是：
AtomicIntegerArray：原子更新整形数组里的元素
AtomicLongArray：原子更新长整形数组里的元素
AtomicReferenceArray：原子更新引用数组里的元素
因为每个类里面提供的方法都一致，因此以AtomicIntegerArray为例来说明。
AtomicIntegerArray主要提供了以原子方式更新数组里的整数，常见方法如下：

以原子的方式将输入值与数组中索引为i的元素相加
int addAndGet(int i, int delta)

如果当前值等于预期值，则以原子方式将数组位置i的元素设置
boolean compareAndSet(int i, int expect, int update)

3.原子更新引用

原子更新基本类型的AtomicInteger只能更新一个变量，如果要原子更新多个变量，就需要使用原子更新引用类型提供的类了。原子引用类型atomic包主要提供了以下几个类：
AtomicReference：原子更新引用类型
AtomicReferenceFieldUpdater：原子更新引用类型里的字段
AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。

以上类中提供的方法基本一致，我们以AtomicReference为例说明：


import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceTest {

    private static AtomicReference<User> reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user = new User("great", 27);
        reference.set(user);
        User updateUser = new User("candy", 23);
        reference.compareAndSet(user, updateUser);
        System.out.println(reference.get().getName());
        System.out.println(reference.get().getAge());
    }


    static class User {

        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

4.原子更新属性

如果需要原子更新某个对象的某个字段，就需要使用原子更新属性的相关类，atomic中提供了一下几个类用于原子更新属性：
AtomicIntegerFieldUpdater：原子更新整形属性的更新器
AtomicLongFieldUpdater：原子更新长整形的更新器
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题。
想要原子的更新字段，需要两个步骤：
1.因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性
2.更新类的字段（属性）必须使用public volatile修饰符
本节仅以AstomicIntegerFieldUpdater为例进行讲解，AstomicIntegerFieldUpdater的示例代码如下：


import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicIntegerFieldUpdaterTest {

    //创建原子更新器
    private static AtomicIntegerFieldUpdater<User> updater = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

    public static void main(String[] args) {
        User user = new User("great", 26);
        //great长了一岁
        updater.getAndIncrement(user);
        System.out.println(updater.get(user));
    }

    static class User {

        private String name;
        public volatile int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }
}

6.CAS 实现原子操作的三大问题

1.ABA 问题

因为 CAS 需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是 A，变成了 B，又变成了 A，那么使用 CAS 进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA 问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加 1，那么 A→B→A 就会变成 1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是 ABA 问题。如果你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的时候水被人动过没有，因为你是程序员，所以就想起了放了张纸在旁边，写上初始值 0，别人喝水前麻烦先做个累加才能喝水。

2.循环时间长开销大

自旋 CAS 如果长时间不成功，会给 CPU 带来非常大的执行开销。

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

当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量 i＝2，j=a，合并一下 ij=2a，然后用 CAS 来操作 ij。

7.解决问题

差点忘了，最后我们用AtomicInteger类，来解决之前的问题。只需将原来的Integer类型，改为AtomicInteger类型，将i++改为 i.getAndIncrement();


    //定义一个静态成员变量i初始值为0
    private static AtomicInteger i = new AtomicInteger(0);


    public static void main(String[] args) throws InterruptedException {
        //启动子线程的数量
        int subThreadQuantity = 2;
        //外层for循环用于创建和启动子线程
        for (int j = 0; j < subThreadQuantity; j++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //内层循环用于对成员变量i自增10000次
                    for (int j = 0; j < 10000; j++) {
                             i.getAndIncrement();
                    }
                }
            }).start();
        }
        //让主线程休眠5秒保证子线程能执行完
        Thread.sleep(5000);
        System.out.println("启动" + subThreadQuantity + "个子线程，分别对i自增10000次，i最终=" + i);

    }

我们运行这段代码5次，输出结果：

启动2个子线程，分别对i自增10000次，i最终=20000
启动2个子线程，分别对i自增10000次，i最终=20000
启动2个子线程，分别对i自增10000次，i最终=20000
启动2个子线程，分别对i自增10000次，i最终=20000
启动2个子线程，分别对i自增10000次，i最终=20000