【Java 基础】Java 引用类型的原子操作

àì夳堔傛蜴生んèń 2024-05-04 08:05 64阅读 0赞

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

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 初阶][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

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

*   *   *  一、引用类型的原子操作
         *  二、AtomicRefrence
         *  三、AtomicStampedReference
         *  四、AtomicMarkableRefrence

#### 一、引用类型的原子操作 ####

Java中的原子操作是指能够以原子方式执行的操作，即在多线程环境下保证操作的原子性，避免竞态条件和数据不一致的问题。Java提供了一些原子类来支持原子操作，其中包括原子引用类型的操作。

Java中的原子引用类型操作主要由以下几个类提供：

*  AtomicReference：用于原子更新引用类型的值。
 *  AtomicStampedReference：用于原子地更新引用类型的值。
 *  AtomicMarkableReference：用于原子更新带有标记的引用类型的值。

这些原子引用类型操作的共同特点是，它们提供了一种机制来确保对引用类型的操作是原子性的，避免了竞态条件和数据不一致的问题。使用这些原子类可以简化多线程编程中对引用类型的同步和锁机制的使用。

例如，AtomicReference类提供了以下几个重要的方法：

*  get()：获取当前引用的值。
 *  set(V newValue)：设置新的引用值。
 *  getAndSet(V newValue)：先获取当前引用的值，然后设置新的引用值。
 *  compareAndSet(V expect, V update)：如果当前引用的值与期望值相等，则设置新的引用值。

使用这些方法可以实现对引用类型的原子操作，确保在多线程环境下的线程安全性。

#### 二、AtomicRefrence ####

AtomicReference是Java中的原子引用类型，它可以用于原子地更新引用类型的值。AtomicReference提供了一些方法来实现线程安全的引用类型操作，以避免竞态条件和数据不一致的问题。

AtomicReference的常用方法包括：

*  get()：获取当前引用的值。
 *  set(V newValue)：设置新的引用值。
 *  compareAndSet(V expect, V update)：如果当前引用的值与期望值相等，则设置新的引用值。
 *  getAndSet(V newValue)：先获取当前引用的值，然后设置新的引用值。

使用AtomicReference可以在多线程环境下安全地更新引用类型的值。例如，可以使用AtomicReference来实现一个线程安全的计数器：

import java.util.concurrent.atomic.AtomicReference;
     
    public class Counter {
        
        private AtomicReference<Integer> count = new AtomicReference<>(0);
         
        public void increment() {
        
            Integer oldValue;
            Integer newValue;
            do {
        
                oldValue = count.get();
                newValue = oldValue + 1;
            } while (!count.compareAndSet(oldValue, newValue));
        }
         
        public int getCount() {
        
            return count.get();
        }
    }

在上面的代码中，我们使用AtomicReference来存储计数器的值，并在increment方法中使用compareAndSet方法来原子地增加计数器的值。这样可以确保在多线程环境下计数器的操作是线程安全的。

AtomicReference只能保证引用的原子性，而不能保证引用对象内部状态的原子性。如果需要保证引用对象内部状态的原子性，可以考虑使用更加细粒度的原子类，如AtomicInteger、AtomicLong等。

#### 三、AtomicStampedReference ####

AtomicStampedReference是Java中的原子标记引用类型，它可以用于原子地更新引用类型的值，并且可以附带一个标记值。与AtomicMarkableReference类似，AtomicStampedReference提供了一些方法来实现线程安全的引用类型操作，并且可以原子地更新标记值，以避免竞态条件和数据不一致的问题。

AtomicStampedReference的常用方法包括：

*  getReference()：获取当前引用的值。
 *  getStamp()：获取当前标记值的值。
 *  set(V newReference, int newStamp)：设置新的引用值和标记值。
 *  compareAndSet(V expectReference, V newReference, int expectStamp, int newStamp)：如果当前引用的值和标记值与期望值相等，则设置新的引用值和标记值。
 *  weakCompareAndSet(V expectReference, V newReference, int expectStamp, int newStamp)：与compareAndSet方法类似，但是使用弱比较和设置。  
    使用AtomicStampedReference可以在多线程环境下安全地更新引用类型的值和标记值。例如，可以使用AtomicStampedReference来实现一个线程安全的计数器：

import java.util.concurrent.atomic.AtomicStampedReference;
    
    public class Counter {
        
        private AtomicStampedReference<Integer> counter = new AtomicStampedReference<>(0, 0);
        
        public int getCount() {
        
            return counter.getReference();
        }
        
        public void increment() {
        
            int[] stamp = new int[1];
            int value = counter.get(stamp);
            while (!counter.compareAndSet(value, value + 1, stamp[0], stamp[0] + 1)) {
        
                value = counter.get(stamp);
            }
        }
    }

在上面的代码中，我们使用AtomicStampedReference来存储计数器的值，并在increment方法中使用compareAndSet方法来原子地更新计数器的值和标记值。这样可以确保在多线程环境下计数器的操作是线程安全的。

AtomicStampedReference只能保证引用和标记值的原子性，而不能保证引用对象内部状态的原子性。如果需要保证引用对象内部状态的原子性，可以考虑使用更加细粒度的原子类，如AtomicReference、AtomicInteger等。

#### 四、AtomicMarkableRefrence ####

AtomicMarkableReference是Java中的原子标记引用类型，它可以用于原子地更新引用类型的值，并且可以附带一个标记位。AtomicMarkableReference提供了一些方法来实现线程安全的引用类型操作，并且可以原子地更新标记位，以避免竞态条件和数据不一致的问题。

AtomicMarkableReference的常用方法包括：

*  getReference()：获取当前引用的值。
 *  isMarked()：获取当前标记位的值。
 *  set(V newReference, boolean newMark)：设置新的引用值和标记位。
 *  compareAndSet(V expectReference, V newReference, boolean expectMark, boolean newMark)：

如果当前引用的值和标记位与期望值相等，则设置新的引用值和标记位。

*  weakCompareAndSet(V expectReference, V newReference, boolean expectMark, boolean newMark)：与compareAndSet方法类似，但是使用弱比较和设置。

使用AtomicMarkableReference可以在多线程环境下安全地更新引用类型的值和标记位。例如，可以使用AtomicMarkableReference来实现一个线程安全的缓存：

import java.util.concurrent.atomic.AtomicMarkableReference;
    
    public class Cache<K, V> {
        
        private AtomicMarkableReference<Node<K, V>> reference = new AtomicMarkableReference<>(null, false);
        
        public V get(K key) {
        
            Node<K, V> node;
            boolean[] mark = new boolean[1];
            do {
        
                node = reference.get(mark);
                if (node == null || node.key.equals(key)) {
        
                    return node != null ? node.value : null;
                }
            } while (!reference.compareAndSet(node, node, mark[0], false));
            return null;
        }
        
        public void put(K key, V value) {
        
            Node<K, V> newNode = new Node<>(key, value);
            boolean[] mark = new boolean[1];
            do {
        
                Node<K, V> node = reference.get(mark);
                newNode.next = node;
            } while (!reference.compareAndSet(reference.getReference(), newNode, mark[0], false));
        }
        
        private static class Node<K, V> {
        
            private final K key;
            private final V value;
            private Node<K, V> next;
            
            public Node(K key, V value) {
        
                this.key = key;
                this.value = value;
            }
        }
    }

在上面的代码中，我们使用AtomicMarkableReference来存储缓存的节点，并在get和put方法中使用compareAndSet方法来原子地更新节点的值和标记位。这样可以确保在多线程环境下缓存的操作是线程安全的。

AtomicMarkableReference只能保证引用和标记位的原子性，而不能保证引用对象内部状态的原子性。如果需要保证引用对象内部状态的原子性，可以考虑使用更加细粒度的原子类，如AtomicReference、AtomicInteger等。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[c95284a90aba4f458dc7a75309b57fe6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/c8f79b6eae77463f933c5816d89d329e.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center