likes
comments
collection
share

AtomicInteger原理，CAS 机制，乐观锁，ABA问题CAS(Compare And Swap) CAS的原理

作者站长头像
站长
· 阅读数 13

CAS(Compare And Swap)

CAS的原理

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

AtomicInteger原理，CAS 机制，乐观锁，ABA问题CAS(Compare And Swap) CAS的原理

什么是原子操作？如何实现原子操作？

假定有两个操作A和B(A和B可能都很复杂)，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B，那么A和B对彼此来说是原子的。

实现原子操作可以使用锁，锁机制，满足基本的需求是没有问题的了，但是有的时候我们的需求并非这么简单，我们需要更有效，更加灵活的机制，synchronized关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程需要等待，直到该线程释放锁，

这里会有些问题：首先，如果被阻塞的线程优先级很高很重要怎么办？其次，如果获得锁的线程一直不释放锁怎么办？（这种情况是非常糟糕的）。还有一种情况，如果有大量的线程来竞争资源，那CPU将会花费大量的时间和资源来处理这些竞争，同时，还有可能出现一些例如死锁之类的情况，最后，其实锁机制是一种比较粗糙，粒度比较大的机制，相对于像计数器这样的需求有点儿过于笨重。

实现原子操作还可以使用当前的处理器基本都支持CAS()的指令，只不过每个厂家所实现的算法并不一样，每一个CAS操作过程都包含三个运算符：一个内存地址V，一个期望的值A和一个新值B，操作的时候如果这个地址上存放的值等于这个期望的值A，则将地址上的值赋为新值B，否则不做任何操作。

CAS的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事儿，但是要返回原值是多少。循环CAS就是在一个循环里不断的做cas操作，直到成功为止。

示例：

  • 演示基本类型的原子操作类
import java.util.concurrent.atomic.AtomicInteger;

/**
 *类说明：演示基本类型的原子操作类
 */
public class UseAtomicInt {

    static AtomicInteger ai = new AtomicInteger(10);
    
    public static void main(String[] args) {
        //先get再加1
        System.out.println("getAndIncrement==="+ai.getAndIncrement());
        //先加1再get
        System.out.println("incrementAndGet==="+ai.incrementAndGet());
        //先加再get
        System.out.println("addAndGet==="+ai.addAndGet(24));
        //先get再加
        System.out.println("getAndAdd==="+ai.getAndAdd(24));
    }
}

运行结果：

getAndIncrement===10
incrementAndGet===12
addAndGet===36
getAndAdd===36

源码

  • 从 AtomicInteger 静态代码块可以看到，在类初始化的时候拿到值的偏移量（获取偏移量后直接操作内存，从内存取值，不通过缓冲区）。在构造函数保存初始值，并且是volatile修饰
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
    private static final long VALUE;

    static {
        try {
            VALUE = U.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (ReflectiveOperationException e) {
            throw new Error(e);
        }
    }

    private volatile int value;

    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
  • 查看decrementAndGet源码
public final int decrementAndGet() {
        return U.getAndAddInt(this, VALUE, -1) - 1;
    }
  • U是sun.misc.Unsafe类里面的，找到Unsafe里面的getAndAddInt
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }
  • var1就是atomic对象，var2就是偏移量，var4就是要做的减1。var5是通过对象起始地址偏移VALUE的距离，拿到9（示例代码设置的9），是从主内存拿的。
  • compareAndSwapInt就是 CAS 机制
  • 首先计算var5 + var4的值，然后存储一份，然后再通过var1, var2在内存中拿到atomic的值，对比拿到的和var5 + var4的值是否相等，如果相等就允许var5减一（var5与var5 + var4交换）然后返回，如果不等就一直循环判断。
  • 在单线程中没有意义反而变复杂了
  • 假如有AB两个线程，A线程在执行var5 + var4的操作之后时间片段用完了，切换到B线程，B线程已经走完了所有流程，值已经被修改为9。再切换到A线程的时候接着执行通过var1, var2在内存中拿到atomic的值，对比拿到的和var5 + var4的值是否相等就会发现不相等了，因为已经被修改了，然后重新执行do循环里面的操作，重新在内存取值，取到9，然后判断是相等的，也就跳出循环了。
  • 对比拿到的和var5 + var4的值是否相等和对var5赋值是有CPU保证操作是原子性的
  • 这也是乐观锁
  • 没有通过复杂的机制来阻塞线程，并且达到目的，比加锁的代码效率提高很多
  • 但是只适合少量并发中使用，高并发中会导致CPU占用率高。
  • 这种乐观锁（无锁）机制还有一个ABA问题。假如操作的是引用类型，在AB两个线程中，一开始对象是a，在循环中间把对象换成了b，然后又换成了a，对比结果还是a，但是其实中间做了很多其他事情，在并发中可能会导致严重问题

CAS的问题

ABA问题

因为CAS需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。

ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。

如果你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的时候水被人动过没有，因为你是程序员，所以就想起了放了张纸在旁边，写上初始值0，别人喝水前麻烦先做个累加才能喝水。

  • 解决：使用 AtomicStampedReference

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 *类说明：演示带版本戳的原子操作类
 */
public class UseAtomicStampedReference {
    static AtomicStampedReference<String> asr
            = new AtomicStampedReference("BALA-BALA",0);

    public static void main(String[] args) throws InterruptedException {
        //拿到当前的版本号(旧)
        final int oldStamp = asr.getStamp();
        final String oldReference = asr.getReference();
        System.out.println(oldReference+"============"+oldStamp);

        Thread rightStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":当前变量值："
                        +oldReference + "-当前版本戳：" + oldStamp + "-"
                  + asr.compareAndSet(oldReference,
                        oldReference + "+Java", oldStamp,
                        oldStamp + 1));
            }
        });

        Thread errorStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                String reference = asr.getReference();
                System.out.println(Thread.currentThread().getName()
                        +":当前变量值："
                        +reference + "-当前版本戳：" + asr.getStamp() + "-"
                        + asr.compareAndSet(reference,
                        reference + "+C", oldStamp,
                        oldStamp + 1));
            }
        });
        rightStampThread.start();
        rightStampThread.join();
        errorStampThread.start();
        errorStampThread.join();

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

打印结果：

BALA-BALA============0
Thread-0:当前变量值：BALA-BALA-当前版本戳：0-true
Thread-1:当前变量值：BALA-BALA+Java-当前版本戳：1-false
BALA-BALA+Java============1

开销问题

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

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

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。

还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

  • 解决：把多个变量放在类中，再使用 AtomicReference

import java.util.concurrent.atomic.AtomicReference;

/**
 *类说明：演示引用类型的原子操作类
 */
public class UseAtomicReference {
    static AtomicReference<UserInfo> atomicUserRef;
    public static void main(String[] args) {
        UserInfo user = new UserInfo("AAA", 15);//要修改的实体的实例
        atomicUserRef = new AtomicReference(user);
        UserInfo updateUser = new UserInfo("BBB",17);
        atomicUserRef.compareAndSet(user,updateUser);

        System.out.println(atomicUserRef.get());
        System.out.println(user);
    }
    
    //定义一个实体类
    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 int getAge() {
            return age;
        }

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

}

打印结果：

UserInfo{name='BBB', age=17}
UserInfo{name='AAA', age=15}

Jdk中相关原子操作类的使用

AtomicInteger

•int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。

•boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。

•int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。

•int getAndSet（int newValue）：以原子方式设置为newValue的值，并返回旧值。

AtomicIntegerArray

主要是提供原子的方式更新数组里的整型，其常用方法如下。

•int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。

•boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。

更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类。

AtomicReference

原子更新引用类型。

AtomicStampedReference

利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在ABA问题了。这就是AtomicStampedReference的解决方案。AtomicMarkableReference跟AtomicStampedReference差不多， AtomicStampedReference是使用pair的int stamp作为计数器使用，AtomicMarkableReference的pair使用的是boolean mark。 还是那个水的例子，AtomicStampedReference可能关心的是动过几次，AtomicMarkableReference关心的是有没有被人动过，方法都比较简单。

AtomicMarkableReference：

原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，booleaninitialMark）。

转载自:https://juejin.cn/post/7423957532260974592
评论
请登录