10 - 原子类（JUC系列）

爱被打了一巴掌 2024-03-25 16:46 91阅读 0赞

**目录**

一、基本类型原子类

二、数组类型原子类

三、引用类型原子类

四、对象的属性修改原子类

AtomicInteger和AtomicIntegerFieldUpdater有什么区别？

--------------------

原子类是CAS思想的应用！如果不清楚CAS可查看上一章节。

所谓原子类，前面也说过了，就是指 java.util.concurrent.atomic包下的所有的类:

![5780f96bfdf9422b86f5caa800ac4d7b.png][]

学习上，都是相通的，没必要挨个去学习。

我们可以将上述的原子类进行再分类：

## 一、基本类型原子类 ##

*  AtomicBoolean
 *  AtomicInteger
 *  AtomicLong

常见常用API：

![296686cc00e046f4b3ab6a2c8a122a8f.png][]

代码演示

package com.hssy.sqldemo.juc;
    
    import java.util.concurrent.*;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class AtomicIntegerDemo {
    
    
        public static void main(String[] args) {
            int threadCount = 50;
            MyNumber myNumber = new MyNumber();
            for (int i = 0; i < threadCount; i++) {
                new Thread(()->{
                    for (int j = 0; j < 1000; j++) {
                        myNumber.addPlus();
                    }
                }).start();
            }
    
            // 需要等待一下，让所有线程都执行完成,否则后面获取到的值并不一定是最终值
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
    
            System.out.println(myNumber.get());
        }
    }
    class MyNumber{
        private AtomicInteger atomicInteger = new AtomicInteger();
    
        public int get() {
            return atomicInteger.get();
        }
    
        public void addPlus() {
            atomicInteger.getAndIncrement();
        }
    }

![6c92237b8aff4a61b81926a3775b6395.png][]

ok~

不过这里补充一点额外知识，因为我们要获取最终的值必须等到所有线程任务都执行结束。

否则，获取到的结果就不准确。那么如何判断线程任务是否执行结束呢？

最先想到的可能是像上面这样，给主线程停一段时间，预估任务执行完成后再获取值。

这样其实是不对的，一是必须等到sleep时间过后才能去获取，二是如果出现网络抖动等各种问题，是无法确定线程实际执行时间的。

那么，有什么办法解决了？

使用闭锁CountDownLatch

package com.hssy.sqldemo.juc;
    
    import java.util.concurrent.*;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.function.Supplier;
    
    public class AtomicIntegerDemo {
    
        /**
         * 可以使用闭锁
         *
         */
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            int threadCount = 50;
            MyNumber myNumber = new MyNumber();
            CountDownLatch countDownLatch = new CountDownLatch(threadCount);
            for (int i = 0; i < threadCount; i++) {
                new Thread(()->{
                    try {
                        for (int j = 0; j < 1000; j++) {
                            myNumber.addPlus();
                        }
                    }finally {
                        countDownLatch.countDown();
                    }
    
                }).start();
            }
            countDownLatch.await();
            System.out.println(myNumber.get());
        }
    }
    
    
    class MyNumber{
        private AtomicInteger atomicInteger = new AtomicInteger();
    
        public int get() {
            return atomicInteger.get();
        }
    
        public void addPlus() {
            atomicInteger.getAndIncrement();
        }
    }

![88e2e35eb66c44458d575e7f5b3089e0.png][]

通过实际执行，发现只要任务线程任务执行结束，就会给闭锁减少一把，当闭锁减少到0的时候，await()方法将不再阻塞，也就直接输出后续的代码了。

## 二、数组类型原子类 ##

*  AtomicIntegerArray
 *  AtomicLongArray
 *  AtomicReferenceArray

以AtomicIntegerArray为例：

![63d46dd2c98440beb4cc4bbb4a240533.png][]

![895557081c6e4482aefb7e1dec705fe0.png][]

![95f411e1c6974137a44ae5f3a6cf3bbe.png][]

![8fede9880b7848f0a559a4da1a961fee.png][]

![cc9a3797858f416ebf39677338c65786.png][]

![96a18532a1ac42a7aa058b9e04124f8e.png][]

![d67c6921c51e463aaebb5793a3833c92.png][]

## 三、引用类型原子类 ##

*  AtomicReference
 *  AtomicStampedReference
 *  AtomicMarkableReference

原子引用类很重要，作用是可以自定义原子类。这在前一章已经讲过了。

我们也使用它AtomicReference写过自旋锁。

也清楚AtomicReference在进行比较并交换的时候，可能会有ABA问题。

通过AtomicStampedReference带有版本号戳记的原子引用类，可以解决ABA问题。

那么，AtomicMarkableReference这个类是干嘛的呢？

其实，它也是一个戳记原子引用类，但是它是状态戳，但是它只能使用一次，因此也叫做一次性戳。

代码演示一下

package com.hssy.sqldemo.juc;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicMarkableReference;
    
    
    
    /**
     * 结论：
     * AtomicStampedReference 的戳是 版本号戳
     * AtomicMarkableReference 的戳是 状态戳
     * 两者都可以解决ABA问题
     * 前者是通过版本号更新的方式解决ABA问题
     * 后者是是状态只能改一次，也即使用一次，即一次性戳，故不存在ABA问题
     */
    
    public class AtomicDemo {
        public static void main(String[] args) {
            AtomicMarkableReference<Integer> markableReference = new AtomicMarkableReference<>(100, false);
            new Thread(()->{
                boolean marked = markableReference.isMarked();
                System.out.println(Thread.currentThread().getName() + "线程的初始标识：" + marked);
                // 暂停1s 保证线程B拿到同样的初始标识
                try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
    
                markableReference.compareAndSet(100,500,marked,!marked);
    
                // 标志是否可以反复修改，如果可以则修改一定成功
                boolean b = markableReference.compareAndSet(500, 100, !marked, marked);
                System.out.println("标志是否可以反复修改：" + b );
            },"A").start();
    
            new Thread(()->{
                boolean marked = markableReference.isMarked();
                System.out.println(Thread.currentThread().getName() + "线程的初始标识：" + marked);
    
                // 暂停2s，保证让线程A执行完成
                try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}
    
                System.out.println(
                        Thread.currentThread().getName() +
                        "线程是否修改成功：" +
                        markableReference.compareAndSet(100,2000,marked,!marked) +
                        "  修改后的值为： " +
                        markableReference.getReference() +
                        "  当前的标志为：" +
                        markableReference.isMarked()
                );
            },"B").start();
        }
    }

![7f354db4c9634d7f9bb3654d29105401.png][]

## 四、对象的属性修改原子类 ##

*  AtomicIntegerFieldUpdater
 *  AtomicLongFieldUpdater
 *  AtomicReferenceFieldUpdater

> 思考：

#### **AtomicInteger**和**AtomicIntegerFieldUpdater**有什么区别？ ####

AtomicInteger和AtomicIntegerFieldUpdater都是的原子类，都能够保证对于一个变量的操作具有原子性，但它们有以下区别：

*  **AtomicInteger**：是一个原子类，能够保证对于一个整型变量的操作具有原子性。它通过CAS（Compare And Swap）操作实现原子性，即先比较目标值是否与预期值相等，如果相等，则将目标值更新为新值。在多线程环境下，CAS操作能够保证对于一个变量的操作具有原子性，从而避免了线程安全问题。AtomicInteger适用于对于整型变量的操作，例如自增、自减等。
 *  **AtomicIntegerFieldUpdater**：也是一个原子类，它能够保证对于一个类的某个整型字段的操作具有原子性，不需要将整个类变成线程安全的。它通过反射机制获取类的某个字段的偏移量，然后使用CAS操作实现对于该字段的原子性操作。需要注意的是，这个字段必须是volatile类型的，不能是static类型的。AtomicIntegerFieldUpdater适用于需要对于类的某个字段的操作具有原子性的场景。

举个例子，假设有如下代码：

public class Counter {
        private volatile int count;
        private static final AtomicIntegerFieldUpdater<Counter> countUpdater = AtomicIntegerFieldUpdater.newUpdater(Counter.class, "count");
        
        public void increment() {
            countUpdater.incrementAndGet(this);
        }
        
        public int getCount() {
            return countUpdater.get(this);
        }
    }

这个代码中，Counter类中的count字段是volatile类型的，然后通过AtomicIntegerFieldUpdater获取count字段的偏移量，从而对于该字段的操作具有原子性。increment()方法用于对于count字段进行自增操作，getCount()方法用于获取count字段的值。这样，我们就可以在不将整个Counter类变成线程安全的情况下，对于count字段进行线程安全的操作。

另外，值得注意的是，AtomicIntegerFieldUpdater的使用场景并不是很广泛，通常情况下，使用AtomicInteger即可满足需求。AtomicIntegerFieldUpdater的使用场景通常是在需要对于某个字段的操作具有原子性，但是又不想将整个类变成线程安全的情况下使用。

[5780f96bfdf9422b86f5caa800ac4d7b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1ab5d61fcf374e1187403520f03b3b24.png
[296686cc00e046f4b3ab6a2c8a122a8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f234077b6ad046d89ac5612477b36f4a.png
[6c92237b8aff4a61b81926a3775b6395.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b59fc1a87f2f44818a9b523f53d0e288.png
[88e2e35eb66c44458d575e7f5b3089e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/01457fde02d74479a128efc3907ed3be.png
[63d46dd2c98440beb4cc4bbb4a240533.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8c69a28e6f854ed3b1b06306c3f9cfd0.png
[895557081c6e4482aefb7e1dec705fe0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d391603d84cd4fbeb8810091b2d8b492.png
[95f411e1c6974137a44ae5f3a6cf3bbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b90973e94f814c97a540354e5ed5e044.png
[8fede9880b7848f0a559a4da1a961fee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/eac032714d5b45b7b0b4c343b1533cf8.png
[cc9a3797858f416ebf39677338c65786.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/56055a26645b4afe952dd120c3fa38e1.png
[96a18532a1ac42a7aa058b9e04124f8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ed9b6b368497431daef169c452b0cb17.png
[d67c6921c51e463aaebb5793a3833c92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/93a009a6a1b84b2e9bdb594e693c5372.png
[7f354db4c9634d7f9bb3654d29105401.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0aa9a7fcc5c240f7802e83fa7119628a.png