当前位置： 技术文章>> Java 中的 AtomicReference 如何使用？

文章标题：Java 中的 AtomicReference 如何使用？
  • 文章分类: 后端
  • 4860 阅读

在Java并发编程中，AtomicReference 是一个重要的工具类，它属于 java.util.concurrent.atomic 包。这个类提供了一种线程安全的方式来更新和操作对象引用，而无需进行外部同步。AtomicReference 的使用极大地简化了并发编程中的许多复杂场景，特别是在需要原子地更新单个变量时。下面，我们将深入探讨 AtomicReference 的工作原理、使用方法以及一些高级应用场景。

一、AtomicReference 的基本介绍

AtomicReference 类通过底层的CAS（Compare-And-Swap，比较并交换）操作来实现对对象引用的原子更新。CAS操作是原子操作的一种，它涉及三个操作数：内存位置（V）、预期原值（A）和新值（B）。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。这个操作是原子的，意味着它在执行过程中不会被线程调度机制中断。

二、AtomicReference 的基本使用

1. 初始化

使用 AtomicReference 前，首先需要对其进行初始化。你可以通过构造函数传入一个初始值，或者先创建一个空的 AtomicReference 并在之后设置其值。

AtomicReference<String> atomicRef = new AtomicReference<>("初始值");
// 或者
AtomicReference<String> emptyRef = new AtomicReference<>();
emptyRef.set("新值");

2. 原子更新

AtomicReference 提供了多种方法来原子地更新对象引用，包括 set(), get(), compareAndSet(), getAndSet(), updateAndGet(), 和 accumulateAndGet() 等。

  • get()：获取当前值。
  • set(V newValue)：设置新值，但这不是原子操作，因为它不依赖于当前值。
  • compareAndSet(V expect, V update)：如果当前值等于预期值，则将其更新为新值。这是 AtomicReference 的核心方法，用于实现原子更新。

示例：

AtomicReference<Integer> counter = new AtomicReference<>(0);
while (counter.compareAndSet(oldVal, oldVal + 1)) {
    // 循环直到成功更新
    oldVal = counter.get();
}
  • getAndSet(V newValue)：原子地获取当前值并设置新值。
Integer oldValue = counter.getAndSet(10);
// 此时，counter的值为10，oldValue为更新前的值
  • updateAndGet(UnaryOperator<V> updateFunction) 和 accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction)：这两个方法允许你以函数式编程的方式更新值。
// updateAndGet
int newValue = counter.updateAndGet(n -> n + 1);
// 累加1

// accumulateAndGet
int result = counter.accumulateAndGet(1, Integer::sum);
// 相当于 counter.set(counter.get() + 1)，但更灵活

三、高级应用场景

1. 锁自由的线程安全数据结构

AtomicReference 可以用来构建无需传统锁机制的线程安全数据结构。例如，实现一个简单的线程安全栈：

public class ThreadSafeStack<T> {
    private final AtomicReference<Node<T>> top = new AtomicReference<>(null);

    private static class Node<T> {
        T item;
        Node<T> next;

        Node(T item, Node<T> next) {
            this.item = item;
            this.next = next;
        }
    }

    public void push(T item) {
        Node<T> newNode = new Node<>(item, top.get());
        while (!top.compareAndSet(newNode.next, newNode)) {
            // 如果CAS失败，重新获取top的值并尝试
            newNode.next = top.get();
        }
    }

    public T pop() {
        Node<T> oldTop;
        Node<T> newTop;
        do {
            oldTop = top.get();
            if (oldTop == null) {
                return null; // 栈为空
            }
            newTop = oldTop.next;
        } while (!top.compareAndSet(oldTop, newTop));
        return oldTop.item;
    }
}

2. 原子更新复杂对象

虽然 AtomicReference 直接操作的是对象引用，但你可以通过它来间接地实现复杂对象的原子更新。例如，如果你有一个复杂的对象，其中包含多个字段，而你只想原子地更新其中一个字段，可以使用 AtomicReference 来封装这个对象，然后通过CAS循环来实现。

3. 延迟初始化

AtomicReference 还可以用于实现延迟初始化（也称为懒汉式单例）的线程安全版本。通过结合 compareAndSet 方法，可以确保实例只被初始化一次，即使在多线程环境下也是如此。

public class LazySingleton {
    private static final AtomicReference<LazySingleton> INSTANCE = 
        new AtomicReference<>();

    private LazySingleton() {}

    public static LazySingleton getInstance() {
        for (;;) {
            LazySingleton current = INSTANCE.get();
            if (current != null) {
                return current;
            }
            LazySingleton newInstance = new LazySingleton();
            if (INSTANCE.compareAndSet(null, newInstance)) {
                return newInstance;
            }
            // 如果CAS失败，说明有其他线程已经创建了实例，循环继续直到获取到实例
        }
    }
}

四、总结

AtomicReference 是Java并发编程中一个非常有用的工具，它利用CAS操作提供了对对象引用的原子更新能力。通过 AtomicReference，开发者可以构建出无需传统锁机制的线程安全数据结构，从而避免锁带来的性能开销和潜在的死锁问题。此外，AtomicReference 的灵活性和强大功能使得它在各种复杂的并发场景下都能发挥重要作用。

在探索Java并发编程的旅程中，码小课网站提供了丰富的资源和教程，帮助你深入理解并掌握这些高级并发工具。通过不断实践和学习，你将能够更加熟练地运用 AtomicReference 和其他并发工具来解决实际问题，提升你的编程技能和项目的并发性能。

推荐文章