【JUC】二十二、常用原子类

淩亂°似流年 2024-02-05 11:52 66阅读 0赞

#### 文章目录 ####

*  1、原子类
 *  2、基本类型的原子类
 *  3、数组类型原子类
 *  4、引用类型原子类
 *  5、对象的属性修改原子类

## 1、原子类 ##

原子类：java.util.concurrent.atomic，原子类支持原子操作，底层是CAS思想和Unsafe类，因此不用加synchronized，也可以在多线程下保证安全性。

![在这里插入图片描述][62e53c5c6b9c4219af1cf5717d56b963.png]

## 2、基本类型的原子类 ##

基本类型原子类：

*  AtomicInteger
 *  AtomicBoolea
 *  AtomicLong

常用API：

*  获取当前的值

public finalint get()

*  获取当前的值，并设置新的值

public finalint getAndSet(int newValue)

*  获取当前的值，并自增

public finalint getAndIncrement()

*  获取当前的值，并自减

public finalint getAndDecrement()

*  获取当前的值，并加上预期的值

public finalint getAndAdd(int delta)

*  如果输入的数值等于预期值，则以原子方式将该值设置为输入值

boolean compareAndSet(int expect,int update)

应用案例：多个线程来同时做自增，搭配辅助类CountDown

class MyNumber{
        
    
        AtomicInteger atomicInteger = new AtomicInteger();
    
        public void addPlus(){
        
            atomicInteger.getAndIncrement();
        }
    }

public class VolatileDemo1 {
        
        //线程数
        public static int size = 50;
    
        public static void main(String[] args) throws InterruptedException {
        
            MyNumber myNumber = new MyNumber();
            //使用辅助类，来卡线程全部线程计算完成的时间
            CountDownLatch countDownLatch = new CountDownLatch(size);
            for (int i = 0; i < size; i++) {
        
                new Thread(() -> {
        
                    try {
        
                        for (int j = 0; j < 1000; j++) {
        
                            myNumber.addPlus();
                        }
                    } finally {
        
                        countDownLatch.countDown();
                    }
                },String.valueOf(i)).start();
            }
            //给上面线程的计算时间，但给长了等太久，给短了算不完，生产中不可用
            //Thread.sleep(2000);
            countDownLatch.await();
            System.out.println(myNumber.atomicInteger.get());
        }
    }

![在这里插入图片描述][502131e0b6684691b7a9f09388305fcc.png]

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

数组类型原子类：

*  AtomicIntegerArray
 *  AtomicLongArray
 *  AtomicReferenceArray

示例：

public class AtomicIntegerArrayDemo {
        
    
        public static void main(String[] args) {
        
            //传入数组的length
            AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(5);
            //传入数组，但只指定长度，则int默认全是0
            AtomicIntegerArray atomicIntegerArray1 = new AtomicIntegerArray(new int[5]);
            //传入数组
            AtomicIntegerArray atomicIntegerArray2 = new AtomicIntegerArray(new int[]{
        1, 2, 3, 4, 5});
    
            for (int i = 0; i < atomicIntegerArray1.length(); i++) {
        
                System.out.println(atomicIntegerArray1.get(i));
            }
    
            System.out.println();
    
            int tmpInt = 0;
            //参数一为下标
            tmpInt = atomicIntegerArray1.getAndSet(0, 1205);
            //getAndSet是先get返回后再set，是i++，不是++i
            System.out.println(tmpInt + "-->set后：" + atomicIntegerArray1.get(0));
            tmpInt = atomicIntegerArray1.getAndIncrement(0);
            System.out.println(tmpInt + "-->set后：" + atomicIntegerArray1.get(0));
        }
    }

![在这里插入图片描述][27d13a4298204701908aee25175bc989.png]

API文档参考：[https://tool.oschina.net/apidocs/apidoc?api=jdk-zh][https_tool.oschina.net_apidocs_apidoc_api_jdk-zh]

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

引用类型原子类：

*  AtomicReference
 *  AtomicStampedReference
 *  AtomicMarkableReference

AtomicReference<T>即传入其他类或者自定义类，包装为原子类，如前一篇的手写自旋锁，泛型传Thread：

public class SpinLockDemo {
        
    
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
        public void lock(){
        
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "\t" + "----come in");
            //自旋，必须当前原子引用类对象值为null，即没有其他线程占用，才抢锁成功
            while(!atomicReference.compareAndSet(null,thread)){
        
    
            }
        }
    
        public void unlock(){
        
            Thread thread = Thread.currentThread();
            //期望值为当前线程，改为null
            atomicReference.compareAndSet(thread,null);
            System.out.println(Thread.currentThread().getName() + "\t" + "----over，unlock...");
        }
    
        
    }

AtomicStampedReference即携带版本号（戳记）的引用类型原子类，用来解决ABA问题。参考[【上一篇】][Link 1] 。AtomicMarkableReference，即带标记的，和AtomicStampedReference的区别是：

*  AtomicStampedReference：version号，每改一次就+1
 *  AtomicMarkableReference：只要被改一次，标记就是false
 *  AtomicStampedReference是记录修改过多少次，Mark则是记录是否修改过

Mark的简单Demo：

public class AtomicMarkDemo {
        
    
        static AtomicMarkableReference<Integer> atomicMarkableReference = new AtomicMarkableReference<>(100,false);
    
        public static void main(String[] args) {
        
            new Thread(() -> {
        
                boolean marked = atomicMarkableReference.isMarked();
                System.out.println(Thread.currentThread().getName() + "\t" + "默认标志：" + marked);
                //别着急改，让t2也拿到和t1一样的marked值
                try {
        
                    TimeUnit.MILLISECONDS.sleep(300);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                atomicMarkableReference.compareAndSet(100,200,marked,!marked);
            },"t1").start();
    
            new Thread(() -> {
        
                boolean marked = atomicMarkableReference.isMarked();
                System.out.println(Thread.currentThread().getName() + "\t" + "默认标志：" + marked);
                //确保让t1先改
                try {
        
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                boolean result = atomicMarkableReference.compareAndSet(100, 300, marked, !marked);
                System.out.println(Thread.currentThread().getName() + "修改结果：" + result);
                System.out.println("当前标记值：" + atomicMarkableReference.isMarked());
                System.out.println("当前对象值：" + atomicMarkableReference.getReference());
    
            },"t2").start();
        }
    }

![在这里插入图片描述][e2970e9675444ceb999c8b373df18eb5.png]

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

更细粒度的更新原子类，以一种线程安全的方式操作非线程安全对象内的某些字段。

*  AtomicIntegerFieldUpdater：原子更新对象中int类型字段的值
 *  AtomicLongFieldUpdater：原子更新对象中Long类型字段的值
 *  AtomicReferenceFieldUpdater：原子更新引用类型字段的值

以银行账户对象为例，更新余额money，高并发下，需要加synchronized，但这样锁的是整个账户对象，能否对money属性单独进行原子更新。这就好比去医院拔牙，全身麻醉与局部嘴麻醉的关系。

![在这里插入图片描述][488e8f92e5194120af3a80c9e76ada39.png]

> **使用要求：**

*  更新的对象属性必须使用 public volatile 修饰符
 *  因为对象属性修改原子类都是抽象类，所以每次使用都必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性

> 案例一：

需求:

*  10个线程
 *  每个线程转账1000
 *  不使用synchronized,尝试使用AtomicIntegerFieldUpdater来实现

先用synchronized实现：

@Getter
    class BankAccount{
        
        private String BankName = "BBC";
        private int money = 0;
        public synchronized void add(){
        
            money++;
        }
    }

public class AtomicIntegerUpdateDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            BankAccount bankAccount = new BankAccount();
            CountDownLatch countDownLatch = new CountDownLatch(10);
            for (int i = 1; i <= 10 ; i++) {
        
                new Thread(() -> {
        
                    try {
        
                        for (int j = 0; j < 1000; j++) {
        
                            bankAccount.add();
                        }
                    } finally {
        
                        //每个线程循环1000次后，计数器减一
                        countDownLatch.countDown();
                    }
    
                }).start();
            }
            countDownLatch.await();
            System.out.println(bankAccount.getMoney());
        }
    }
    
    //輸出：10000

改用属性更新原子类：

@Getter
    class BankAccount{
        
        private String BankName = "BBC";
        public volatile int money = 0;
        //使用静态方法newUpdater()创建一个更新器
        AtomicIntegerFieldUpdater<BankAccount> fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(BankAccount.class,"money");
    
        public void changeMoney(BankAccount bankAccount){
        
            fieldUpdater.getAndIncrement(bankAccount);
        }
    }

重新调用新方法：

![在这里插入图片描述][71b8468c4ff44dc697cd5455a5f904fd.png]

以上这个更新原子类，只能更新int类型属性，换AtomicReferenceFieldUpdater，更新引用类型属性。

> 案例二：

需求：

*  多个线程进行饱和式初始化，即并发调用一个类的初始化方法，如果未被初始化过，则执行初始化方法
 *  要求只能被初始化一次，只能一个线程操作成功

class MyResource {
        
        //引用类型
        public volatile Boolean isInit = Boolean.FALSE;
    
        AtomicReferenceFieldUpdater<MyResource, Boolean> fieldUpdater = AtomicReferenceFieldUpdater.newUpdater(MyResource.class, Boolean.class, "isInit");
    
        public void init(MyResource myResource) {
        
            if (fieldUpdater.compareAndSet(myResource, Boolean.FALSE, Boolean.TRUE)) {
        
                //执行初始化逻辑
                System.out.println(Thread.currentThread().getName() + " init ...");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " init over!");
            } else {
        
                System.out.println(Thread.currentThread().getName() + "不用更新，已有线程正在更新...");
            }
        }
    }
    
    public class AtomicUpdateDemo {
        
    
        public static void main(String[] args) {
        
            MyResource myResource = new MyResource();
            for (int i = 1; i <= 5; i++) {
        
                new Thread(() -> {
        
                    myResource.init(myResource);
                },String.valueOf(i)).start();
            }
        }
    }

![在这里插入图片描述][126c5558ac474e839c935b19bff74a82.png]

[62e53c5c6b9c4219af1cf5717d56b963.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/1b875db1ae4f4ac19c21f2a118a86cdf.png
[502131e0b6684691b7a9f09388305fcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/35e9fbb9cb434613b759054408c473f9.png
[27d13a4298204701908aee25175bc989.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/e7a23ff350ce470bab2267f0897c2961.png
[https_tool.oschina.net_apidocs_apidoc_api_jdk-zh]: https://tool.oschina.net/apidocs/apidoc?api=jdk-zh
[Link 1]: https://blog.csdn.net/llg___/article/details/134788063
[e2970e9675444ceb999c8b373df18eb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/84860c843bfb47cfa82f9b6d8629f3ff.png
[488e8f92e5194120af3a80c9e76ada39.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/ea53c75e0c7f4cee97c50ef3105e21f1.png
[71b8468c4ff44dc697cd5455a5f904fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/d0cb39d019e4449492be17fb4b2cf393.png
[126c5558ac474e839c935b19bff74a82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/87ad94fc0fb648509c53bc32984556a8.png