CAS原子操作、原子操作类

小灰灰 2022-02-26 02:52 418阅读 0赞

## 1、乐观锁与悲观锁 ##

我们都知道，cpu是时分复用的，也就是把cpu的时间片，分配给不同的thread/process轮流执行，时间片与时间片之间，需要进行cpu切换，也就是会发生进程的切换。切换涉及到清空寄存器，缓存数据。然后重新加载新的thread所需数据。当一个线程被挂起时，加入到阻塞队列，在一定的时间或条件下，在通过notify()，notifyAll()唤醒回来。 **在某个资源不可用的时候，就将cpu让出，把当前等待线程切换为阻塞状态。等到资源(比如一个共享数据）可用了，那么就将线程唤醒，让他进入runnable状态等待cpu调度。这就是典型的悲观锁的实现。** 独占锁是一种悲观锁，synchronized就是一种独占锁，它假设最坏的情况，认为一个线程修改共享数据的时候其他线程也会修改该数据，因此只在确保其它线程不会造成干扰的情况下执行，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。

**        但是，由于在进程挂起和恢复执行过程中存在着很大的开销**。当一个线程正在等待锁时，它不能做任何事，所以悲观锁有很大的缺点。举个例子，如果一个线程需要某个资源，但是这个资源的占用时间很短，当线程第一次抢占这个资源时，可能这个资源被占用，如果此时挂起这个线程，可能立刻就发现资源可用，然后又需要花费很长的时间重新抢占锁，时间代价就会非常的高。

所以就有了乐观锁的概念，他的核心思路就是，**每次不加锁而是假设修改数据之前其他线程一定不会修改，如果因为修改过产生冲突就失败就重试，直到成功为止。** 在上面的例子中，某个线程可以不让出cpu，而是一直while循环，如果失败就重试，直到成功为止。所以，当数据争用不严重时，乐观锁效果更好。比如CAS就是一种乐观锁思想的应用。

## 2、CAS ##

**       CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。执行CAS操作的时候，将内存位置的值与预期原值比较，如果相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。**

举个CAS操作的应用场景的一个例子，当一个线程需要修改共享变量的值。完成这个操作，先取出共享变量的值赋给A，然后基于A的基础进行计算，得到新值B，完了需要更新共享变量的值了，这个时候就可以调用CAS方法更新变量值了。

在java中可以通过锁和循环CAS的方式来实现原子操作。

下面我们来已AtomicInteger的源码为例来看看CAS操作：

public final int getAndUpdate(int delta) {
        for (; ; ) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return current;
        }
    }

这里很显然使用CAS操作（for(;;)里面），他每次都从内存中读取数据，+1操作，然后两个值进行CAS操作。如果成功则返回，否则失败重试，直到修改成功为止。上面源码最关键的地方有两个，一个for循环，它代表着一种宁死不屈的精神，不成功誓不罢休。还有就是compareAndSet：

public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

compareAndSet方法内部是调用Java本地方法compareAndSwapInt来实现的，而compareAndSwapInt方法内部又是借助C来调用CPU的底层指令来保证在硬件层面上实现原子操作的。在intel处理器中，CAS是通过调用**cmpxchg**指令完成的。这就是我们常说的**CAS操作**（compare and swap）。

## 3、CAS的问题 ##

CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作。

*  ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
 *  循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。
 *  只能保证一个共享变量的原子操作（一个地址指向一个变量）。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

## **[4、原子操作类][4]** ##

当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变量i=1，A线程更新i+1，B线程也更新i+1，经过两个线程操作之后可能i不等于3，而是等于2。因为A和B线程在更新变量i的时候拿到的i都是1，这就是线程不安全的更新操作，通常我们会使用synchronized来解决这个问题，synchronized会保证多线程不会同时更新变量i。

而Java从JDK 1.5开始提供了java.util.concurrent.atomic包（以下简称Atomic包），这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。

因为变量的类型有很多种，所以在Atomic包里也提供了很多类，大致可以属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性（字段）。Atomic包里的类基本都是使用Unsafe实现的包装类。

### 4.1、更新基本类型 ###

**使用原子的方式更新基本类型，Atomic包提供了以下3个类**。

*  AtomicBoolean:原子更新布尔类型。
 *  AtomicInteger：原子更新整型。
 *  AtomicLong：原子更新Long类型。

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

*  **int addAndGet(int delta)：** 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
 *  **boolean compareAndSet(int expect，int update)：**如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
 *  **int getAndIncrement()：**以原子方式将当前值加1，注意，这里返回的是自增前的值。
 *  **int getAndDecrement()：**以原子方式将当前值减1，注意，这里返回的是自减前的值。
 *  **int getAndSet（int newValue）：**以原子方式设置为newValue的值，并返回旧值。
 *  **int IncrementAndget()：**以原子方式将当前值加1，注意，这里返回的是自增后的值。
 *  **int DecrementAndget()：**以原子方式将当前值减1，注意，这里返回的是自减后的值。

public class AtomicDemo {
        private static AtomicInteger atomicInteger = new AtomicInteger(1);
    
        public static void main(String[] args) {
            System.out.println(atomicInteger.getAndIncrement());
            System.out.println(atomicInteger.get());
        }
    }
    输出结果：
    1
    2

### **4.2 、原子更新数组类型** ###

atomic包下提供能原子更新数组中元素的类有：

1.  AtomicIntegerArray：原子更新整型数组中的元素；
2.  AtomicLongArray：原子更新长整型数组中的元素；
3.  AtomicReferenceArray：原子更新引用类型数组中的元素

这几个类的用法一致，就以AtomicIntegerArray来总结下常用的方法：

*  addAndGet(int i, int delta)：以原子更新的方式将数组中索引为i的元素与输入值相加；
 *  getAndIncrement(int i)：以原子更新的方式将数组中索引为i的元素自增加1；
 *  compareAndSet(int i, int expect, int update)：将数组中索引为i的位置的元素进行更新

可以看出，AtomicIntegerArray与AtomicInteger的方法基本一致，只不过在AtomicIntegerArray的方法中会多一个指定数组索引位i。下面举一个简单的例子：

public class AtomicDemo {
        //    private static AtomicInteger atomicInteger = new AtomicInteger(1);
        private static int[] value = new int[]{1, 2, 3};
        private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);
    
        public static void main(String[] args) {
            //对数组中索引为1的位置的元素加5
            int result = integerArray.getAndAdd(1, 5);
            System.out.println(integerArray.get(1));
            System.out.println(result);
        }
    }
    输出结果：
    7
    2

通过getAndAdd方法将位置为1的元素加5，从结果可以看出索引为1的元素变成了7，该方法返回的也是相加之前的数为2。

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

### **4.3、原子更新引用类型** ###

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

*  AtomicReference：原子更新引用类型
 *  AtomicStampReference：原子更新引用类型，这种更新方式会带有版本号。而为什么在更新的时候会带有版本号，是为了解决CAS的ABA问题。
 *  AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，boolean initialMark）。针对ABA问题，有没有人动过。

以上几个类提供的方法几乎一样，所以此处我们仅以AtomicReference为例进行讲解，AtomicReference的使用示例代码如下：

public static AtomicReference<User> atomicUserRef = new
            AtomicReference<User>();
    
    public static void main(String[] args) {
        User user = new User("conan", 15);
        atomicUserRef.set(user);
        User updateUser = new User("Shinichi", 17);
        atomicUserRef.compareAndSet(user, updateUser);
        System.out.println(atomicUserRef.get().getName());
        System.out.println(atomicUserRef.get().getOld());
    }
    static class User {
        private String name;
        private int old;
        public User(String name, int old) {
            this.name = name;
            this.old = old;
        }
        public String getName() {
            return name;
        }
        public int getOld() {
            return old;
        }
    }// 运行结果
    Shinichi
    17

### **4.4. 原子更新字段类型** ###

如果需要更新对象的某个字段，并在多线程的情况下，能够保证线程安全，atomic同样也提供了相应的原子操作类：

1.  AtomicIntegeFieldUpdater：原子更新整型字段类；
2.  AtomicLongFieldUpdater：原子更新长整型字段类；

要想使用原子更新字段需要两步操作：

1.  原子更新字段类都是抽象类，只能通过静态方法**`newUpdater`**来创建一个更新器，并且需要设置想要更新的类和属性；
2.  更新类的属性必须使用**`public volatile`**进行修饰；

这几个类提供的方法基本一致，以AtomicIntegerFieldUpdater为例来看看具体的使用：

public class AtomicDemo {
    
        private static AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
        public static void main(String[] args) {
            User user = new User("a", 1);
            int oldValue = updater.getAndAdd(user, 5);
            System.out.println(oldValue);
            System.out.println(updater.get(user));
        }
    
        static class User {
            private String userName;
            public volatile int age;
    
            public User(String userName, int age) {
                this.userName = userName;
                this.age = age;
            }
    
            @Override
            public String toString() {
                return "User{" +
                        "userName='" + userName + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    } 
    
    输出结果：
    1
    6

从示例中可以看出，创建`AtomicIntegerFieldUpdater`是通过它提供的静态方法进行创建，`getAndAdd`方法会将指定的字段加上输入的值，并且返回相加之前的值。user对象中age字段原值为1，加5之后，可以看出user对象中的age字段的值已经变成了6。

[4]: https://www.cnblogs.com/boothsun/p/8010692.html