线程、多线程之Atomic 简述

浅浅的花香味﹌ 2023-02-18 11:50 26阅读 0赞

### [1. 介绍一下Atomic 原子类][1. _Atomic] ###

Atomic 翻译成中文是原子的意思(事务的四个特性ACID，其中A就是原子性)。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。

![JUC原子类概览][JUC]

### [2. JUC 包中的原子类是哪4类?][2. JUC _4] ###

**2.1 基本类型**

用原子的方式更新基本类型

*  tomicInteger：整形原子类
 *  AtomicLong：长整型原子类
 *  AtomicBoolean：布尔型原子类

**2.2 数组类型**

使用原子的方式更新数组里的某个元素

*  AtomicIntegerArray：整形数组原子类
 *  AtomicLongArray：长整形数组原子类
 *  AtomicReferenceArray：引用类型数组原子类

**2.3 引用类型**

*  AtomicReference：引用类型原子类
 *  AtomicStampedReference：原子更新引用类型里的字段原子类
 *  AtomicMarkableReference ：原子更新带有标记位的引用类型

**2.4 对象的属性修改类型**

*  AtomicIntegerFieldUpdater：原子更新整形字段的更新器
 *  AtomicLongFieldUpdater：原子更新长整形字段的更新器
 *  AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

### [3. 讲讲 AtomicInteger 的使用][3. _ AtomicInteger] ###

**3.1 AtomicInteger 类常用方法**

public final int get() //获取当前的值
    public final int getAndSet(int newValue)//获取当前的值，并设置新的值
    public final int getAndIncrement()//获取当前的值，并自增
    public final int getAndDecrement() //获取当前的值，并自减
    public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
    boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
    public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。Copy to clipboardErrorCopied

**3.2 AtomicInteger 类的使用示例**

使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。

class AtomicIntegerTest {
            private AtomicInteger count = new AtomicInteger();
          //使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
            public void increment() {
                      count.incrementAndGet();
            }
    
           public int getCount() {
                    return count.get();
            }
    }

[4. 能不能给我简单介绍一下 AtomicInteger 类的原理][4. _ AtomicInteger]

**4.1 AtomicInteger 线程安全原理简单分析**

AtomicInteger 类的部分源码：

// setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
    
        private volatile int value;

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

**4.2 简单了解下 CAS**

CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。

通俗一点来说，CAS的执行需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作。

**4.3 示例说明CAS**

多线程的过程中对变量累加操作：

public static volatile int count = 0;
        public static int STEP = 20;
        private static CountDownLatch countDownLatch = new CountDownLatch(STEP);
    
        //public static AtomicInteger count = new AtomicInteger();
        public static void sumForThread(){
             count ++; //之前写法 非原子操作
            //count.getAndIncrement(); // 原子操作
        }
    
        public static void main(String[] args)throws Exception {
            Thread[] threads = new Thread[STEP];
            for (int i = 0; i < STEP; i++) {
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < 10000; i++) {
                            sumForThread();
                        }
                        countDownLatch.countDown();
                    }
                });
                threads[i].start();
            }
            countDownLatch.await();
            System.out.println("*************"+count);
        }

上面的执行结果count 一直徘徊在 20W左边，和我们预期就不太一样，修改之前的 count++；换成了 Atomic原子类操作，这样每次的执行结果和预期完全相符。

public static AtomicInteger count = new AtomicInteger();
        public static void sumForThread(){
            // count ++; 之前写法 非原子操作
            count.getAndIncrement(); // 原子操作
        }

通过查看getAndIncrement()方法源码得知，是unsafe调用了 getAndAddInt()方法，说到这 说下unsafe类，Java中的Unsafe类为我们提供了类似C++手动管理内存的能力。Unsafe类，全限定名是`sun.misc.Unsafe`，从名字中我们可以看出来这个类对普通程序员来说是“危险”的，一般应用开发者不会用到这个类。Unsafe类是"final"的，不允许继承。且构造函数是private的。

![format_png][]

/**
         * Atomically increments by one the current value.
         *
         * @return the previous value
         */
        public final int getAndIncrement() {
            return unsafe.getAndAddInt(this, valueOffset, 1);
        }

继续查看getAndAddInt()方法源码，调用的是 compareAndSwapInt()方法，

public final int getAndAddInt(Object var1, long var2, int var4) {
            int var5;
            do {
                // 获取内存中的最新值
                var5 = this.getIntVolatile(var1, var2);
            // 无限循环直到CAS修改成功结束循环
            } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
            return var5;
        }

**4.4 CAS的缺点**  
CAS虽然很高效的解决了原子操作问题，但是CAS仍然存在几大问题：

循环时间长开销很大；

CAS 通常是配合无限循环一起使用的，我们可以看到 getAndAddInt 方法执行时，如果 CAS 失败，会一直进行尝试。如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销。

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

当对一个变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个变量操作时，CAS 目前无法直接保证操作的原子性。但是我们可以通过以下两种办法来解决：1）使用互斥锁来保证原子性；2）将多个变量封装成对象，通过 AtomicReference 来保证原子性。

ABA问题；

什么是ABA问题？ABA问题怎么解决？  
       如果内存地址V初次读取的值是A，并且在准备赋值的时候检查到它的值仍然为A，那我们就能说它的值没有被其他线程改变过了吗？如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。Java并发包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。  
当然上述示例也可以对方法进行synchronized关键字修饰 也是一种方案。

**如有披露或问题欢迎留言或者入群探讨**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70][]

[1. _Atomic]: https://snailclimb.gitee.io/javaguide/#/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions?id=_51-%E4%BB%8B%E7%BB%8D%E4%B8%80%E4%B8%8Batomic-%E5%8E%9F%E5%AD%90%E7%B1%BB
[JUC]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9teS1ibG9nLXRvLXVzZS5vc3MtY24tYmVpamluZy5hbGl5dW5jcy5jb20vMjAxOS02L0pVQyVFNSU4RSU5RiVFNSVBRCU5MCVFNyVCMSVCQiVFNiVBNiU4MiVFOCVBNyU4OC5wbmc?x-oss-process=image/format,png
[2. JUC _4]: https://snailclimb.gitee.io/javaguide/#/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions?id=_52-juc-%E5%8C%85%E4%B8%AD%E7%9A%84%E5%8E%9F%E5%AD%90%E7%B1%BB%E6%98%AF%E5%93%AA4%E7%B1%BB
[3. _ AtomicInteger]: https://snailclimb.gitee.io/javaguide/#/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions?id=_53-%E8%AE%B2%E8%AE%B2-atomicinteger-%E7%9A%84%E4%BD%BF%E7%94%A8
[4. _ AtomicInteger]: https://snailclimb.gitee.io/javaguide/#/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions?id=_54-%E8%83%BD%E4%B8%8D%E8%83%BD%E7%BB%99%E6%88%91%E7%AE%80%E5%8D%95%E4%BB%8B%E7%BB%8D%E4%B8%80%E4%B8%8B-atomicinteger-%E7%B1%BB%E7%9A%84%E5%8E%9F%E7%90%86
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMTk2MzQ4Ny02MDdhOTY2ZWJhMmVlZDEzLnBuZw?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200521160806979.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz,size_16,color_FFFFFF,t_70