31.jdk源码阅读之AtomicReference

最新推荐文章于 2025-04-23 16:30:46 发布
最新推荐文章于 2025-04-23 16:30:46 发布
阅读量909 收藏 8
点赞数 24
分类专栏： JDK源码 文章标签： java 开发语言
本文为 至真源 原创，转载请注明出处，谢谢！
本文链接：https://blog.youkuaiyun.com/yunkongbian2616/article/details/140817217
版权

1. 写在前面

在这里插入图片描述
AtomicReference 是 Java 中提供的一种用于处理对象引用的原子操作类。它在并发编程中非常有用，可以确保对对象引用的操作是原子的，避免了使用锁的开销。下面的问题不知道大家在日常工作中是否思考过：

  1. AtomicReference 是如何实现原子操作的？
  2. AtomicReference 的 compareAndSet 方法是如何工作的？
  3. AtomicReference 的应用场景有哪些？
  4. AtomicReference 和 synchronized 的区别是什么？
  5. AtomicReference 是否支持泛型？
  6. AtomicReference 和 AtomicInteger 之间的区别是什么？

2. 从使用说起

2.1 基本使用

AtomicReference 可以用来实现对对象引用的原子更新。

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceBasicUsage {
    public static void main(String[] args) {
        AtomicReference<String> atomicString = new AtomicReference<>("initial value");

        // 获取当前值
        String currentValue = atomicString.get();
        System.out.println("Current Value: " + currentValue);

        // 更新值
        atomicString.set("new value");
        System.out.println("Updated Value: " + atomicString.get());

        // 比较并设置值
        boolean isUpdated = atomicString.compareAndSet("new value", "updated value");
        System.out.println("Is Updated: " + isUpdated);
        System.out.println("Final Value: " + atomicString.get());
    }
}

2.2 实现非阻塞栈

使用 AtomicReference 可以实现一个简单的非阻塞栈。

import java.util.concurrent.atomic.AtomicReference;

public class NonBlockingStack<T> {
    private static class Node<T> {
        final T value;
        final Node<T> next;

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

    private final AtomicReference<Node<T>> top = new AtomicReference<>(null);

    public void push(T value) {
        Node<T> newNode = new Node<>(value, null);
        Node<T> oldTop;
        do {
            oldTop = top.get();
            newNode.next = oldTop;
        } while (!top.compareAndSet(oldTop, newNode));
    }

    public T pop() {
        Node<T> oldTop;
        Node<T> newTop;
        do {
            oldTop = top.get();
            if (oldTop == null) {
                return null; // Stack is empty
            }
            newTop = oldTop.next;
        } while (!top.compareAndSet(oldTop, newTop));
        return oldTop.value;
    }

    public static void main(String[] args) {
        NonBlockingStack<Integer> stack = new NonBlockingStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);

        System.out.println(stack.pop()); // 3
        System.out.println(stack.pop()); // 2
        System.out.println(stack.pop()); // 1
    }
}

2.3 实现非阻塞单例模式

使用 AtomicReference 可以实现一个简单的非阻塞单例模式。

import java.util.concurrent.atomic.AtomicReference;

public class NonBlockingSingleton {
    private static final AtomicReference<NonBlockingSingleton> instance = new AtomicReference<>();

    private NonBlockingSingleton() {
        // Private constructor to prevent instantiation
    }

    public static NonBlockingSingleton getInstance() {
        NonBlockingSingleton currentInstance = instance.get();
        if (currentInstance == null) {
            currentInstance = new NonBlockingSingleton();
            if (!instance.compareAndSet(null, currentInstance)) {
                currentInstance = instance.get();
            }
        }
        return currentInstance;
    }

    public static void main(String[] args) {
        NonBlockingSingleton singleton1 = NonBlockingSingleton.getInstance();
        NonBlockingSingleton singleton2 = NonBlockingSingleton.getInstance();
        System.out.println(singleton1 == singleton2); // true
    }
}

2.4 实现多线程安全的缓存

使用 AtomicReference 可以实现一个简单的多线程安全缓存。

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceCache<K, V> {
    private final AtomicReference<Entry<K, V>> cache = new AtomicReference<>();

    private static class Entry<K, V> {
        final K key;
        final V value;

        Entry(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }

    public V get(K key) {
        Entry<K, V> entry = cache.get();
        if (entry != null && entry.key.equals(key)) {
            return entry.value;
        }
        return null;
    }

    public void put(K key, V value) {
        Entry<K, V> newEntry = new Entry<>(key, value);
        cache.set(newEntry);
    }

    public static void main(String[] args) {
        AtomicReferenceCache<String, String> cache = new AtomicReferenceCache<>();
        cache.put("key1", "value1");
        System.out.println(cache.get("key1")); // value1
    }
}

2.5 实现非阻塞队列

使用 AtomicReference 可以实现一个简单的非阻塞队列。

import java.util.concurrent.atomic.AtomicReference;

public class NonBlockingQueue<T> {
    private static class Node<T> {
        final T value;
        final AtomicReference<Node<T>> next;

        Node(T value) {
            this.value = value;
            this.next = new AtomicReference<>(null);
        }
    }

    private final AtomicReference<Node<T>> head;
    private final AtomicReference<Node<T>> tail;

    public NonBlockingQueue() {
        Node<T> dummy = new Node<>(null);
        head = new AtomicReference<>(dummy);
        tail = new AtomicReference<>(dummy);
    }

    public void enqueue(T value) {
        Node<T> newNode = new Node<>(value);
        Node<T> oldTail;
        Node<T> tailNext;
        while (true) {
            oldTail = tail.get();
            tailNext = oldTail.next.get();
            if (oldTail == tail.get()) {
                if (tailNext == null) {
                    if (oldTail.next.compareAndSet(null, newNode)) {
                        tail.compareAndSet(oldTail, newNode);
                        return;
                    }
                } else {
                    tail.compareAndSet(oldTail, tailNext);
                }
            }
        }
    }

    public T dequeue() {
        Node<T> oldHead;
        Node<T> oldTail;
        Node<T> headNext;
        while (true) {
            oldHead = head.get();
            oldTail = tail.get();
            headNext = oldHead.next.get();
            if (oldHead == head.get()) {
                if (oldHead == oldTail) {
                    if (headNext == null) {
                        return null; // Queue is empty
                    }
                    tail.compareAndSet(oldTail, headNext);
                } else {
                    T value = headNext.value;
                    if (head.compareAndSet(oldHead, headNext)) {
                        return value;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        NonBlockingQueue<Integer> queue = new NonBlockingQueue<>();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);

        System.out.println(queue.dequeue()); // 1
        System.out.println(queue.dequeue()); // 2
        System.out.println(queue.dequeue()); // 3
    }
}

3. AtomicReference 和 synchronized 的区别是什么？

AtomicReference 和 synchronized 都是用于在多线程环境下确保操作安全的机制，但它们在实现方式、性能和适用场景上有很大的区别。

3.1 实现方式

  • AtomicReference：使用底层的 CAS（Compare-And-Swap）操作来实现原子性。CAS 是一种硬件级别的原子操作，可以确保在多线程环境下对内存的修改是安全的。
  • synchronized：使用内置的锁机制来确保同一时间只有一个线程可以执行被 synchronized 修饰的代码块或方法。

3.2 性能

  • AtomicReference：由于使用的是无锁的 CAS 操作，通常比 synchronized 更高效，尤其是在高并发环境下。它避免了线程上下文切换和阻塞问题。
  • synchronized：使用锁机制，在高并发环境下可能会导致线程阻塞和上下文切换，性能相对较低。

3.3 适用场景

  • AtomicReference：适用于简单的原子操作，如更新对象引用、计数器等。
  • synchronized：适用于更复杂的同步需求，如需要在一个代码块中进行多个操作，并且这些操作需要保持原子性。

3.4 使用 AtomicReference 实现线程安全的计数器

import java.util.concurrent.atomic.AtomicReference;

public class AtomicCounter {
    private final AtomicReference<Integer> count = new AtomicReference<>(0);

    public void increment() {
        Integer oldValue, newValue;
        do {
            oldValue = count.get();
            newValue = oldValue + 1;
        } while (!count.compareAndSet(oldValue, newValue));
    }

    public int getCount() {
        return count.get();
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicCounter counter = new AtomicCounter();
        Runnable task = counter::increment;

        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(task);
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("Final count: " + counter.getCount()); // Should print 1000
    }
}

3.5 使用 synchronized 实现线程安全的计数器

public class SynchronizedCounter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter counter = new SynchronizedCounter();
        Runnable task = counter::increment;

        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(task);
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("Final count: " + counter.getCount()); // Should print 1000
    }
}

4. AtomicReference 的 ABA 问题是什么？如何解决？

ABA 问题是指在多线程环境下，一个变量的值从 A 变成 B，然后又变回 A。在这种情况下，使用 CAS（Compare-And-Swap）操作可能会误认为变量的值没有变化，从而导致逻辑上的错误。

4.1 ABA 问题示例

让我们通过一个简单的示例来演示 ABA 问题：

import java.util.concurrent.atomic.AtomicReference;

public class ABADemo {
    private static class Node {
        int value;
        Node next;

        Node(int value) {
            this.value = value;
            this.next = null;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicReference<Node> head = new AtomicReference<>(new Node(1));
        head.get().next = new Node(2);

        Thread t1 = new Thread(() -> {
            Node oldHead = head.get();
            // Simulate some work with the old head
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            // Try to swap the head
            head.compareAndSet(oldHead, oldHead.next);
        });

        Thread t2 = new Thread(() -> {
            Node oldHead = head.get();
            // Simulate ABA problem: A -> B -> A
            Node next = oldHead.next;
            head.compareAndSet(oldHead, next); // A -> B
            head.compareAndSet(next, oldHead); // B -> A
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Head value: " + head.get().value); // Expected: 1, Actual: 1
    }
}

在这个示例中，两个线程 t1 和 t2 试图修改 head。线程 t2 模拟了 ABA 问题，先将 head 从 A 变为 B，然后又变回 A。线程 t1 的 compareAndSet 操作可能会误认为 head 没有变化，从而导致逻辑上的错误。

4.2 解决 ABA 问题

Java 提供了 AtomicStampedReference 和 AtomicMarkableReference 来解决 ABA 问题。它们在引用的同时存储一个额外的标记或版本号，以检测是否发生了 ABA 问题。
使用 AtomicStampedReference 解决 ABA 问题:

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABADemo {
    private static class Node {
        int value;
        Node next;

        Node(int value) {
            this.value = value;
            this.next = null;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Node initialNode = new Node(1);
        initialNode.next = new Node(2);
        AtomicStampedReference<Node> head = new AtomicStampedReference<>(initialNode, 0);

        Thread t1 = new Thread(() -> {
            int[] stampHolder = new int[1];
            Node oldHead = head.get(stampHolder);
            int oldStamp = stampHolder[0];
            // Simulate some work with the old head
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            // Try to swap the head
            head.compareAndSet(oldHead, oldHead.next, oldStamp, oldStamp + 1);
        });

        Thread t2 = new Thread(() -> {
            int[] stampHolder = new int[1];
            Node oldHead = head.get(stampHolder);
            int oldStamp = stampHolder[0];
            // Simulate ABA problem: A -> B -> A
            Node next = oldHead.next;
            head.compareAndSet(oldHead, next, oldStamp, oldStamp + 1); // A -> B
            head.compareAndSet(next, oldHead, oldStamp + 1, oldStamp + 2); // B -> A
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        int[] stampHolder = new int[1];
        System.out.println("Head value: " + head.get(stampHolder).value); // Expected: 1, Actual: 1
        System.out.println("Stamp: " + stampHolder[0]); // Should be greater than 0
    }
}

在这个示例中，AtomicStampedReference 用于存储节点的引用和一个整数标记（版本号）。每次 compareAndSet 操作不仅检查引用是否相同，还检查版本号是否匹配，从而避免了 ABA 问题。

系列文章

1.JDK源码阅读之环境搭建

2.JDK源码阅读之目录介绍

3.jdk源码阅读之ArrayList(上)

4.jdk源码阅读之ArrayList(下)

5.jdk源码阅读之HashMap

6.jdk源码阅读之HashMap（下）

7.jdk源码阅读之ConcurrentHashMap(上)

8.jdk源码阅读之ConcurrentHashMap（下）

9.jdk源码阅读之ThreadLocal

10.jdk源码阅读之ReentrantLock

11.jdk源码阅读之CountDownLatch

12.jdk源码阅读之CyclicBarrier

13.jdk源码阅读之Semaphore

14.jdk源码阅读之线程池(上)

15.jdk源码阅读之线程池(下)

16.jdk源码阅读之ArrayBlockingQueue

17.jdk源码阅读之LinkedBlockingQueue

18.jdk源码阅读之CopyOnWriteArrayList

19.jdk源码阅读之FutureTask

20.jdk源码阅读之CompletableFuture

21.jdk源码阅读之AtomicLong

22.jdk源码阅读之Thread(上)

23.jdk源码阅读之Thread(下)

24.jdk源码阅读之ExecutorService

25.jdk源码阅读之Executors

26.jdk源码阅读之ConcurrentLinkedQueue

27.jdk源码阅读之ConcurrentLinkedDeque

28.jdk源码阅读之CopyOnWriteArraySet

29.jdk源码阅读之Exchanger

30.jdk源码阅读之ReentrantReadWriteLock

JDK源码阅读计划
gongsenlin341的博客
07-17 539
计划阅读顺序如下，优先级1-4，完成一个写一篇博客 1、java.lang Object 1 String 1 AbstractStringBuilder 1 StringBuffer 1 StringBuilder 1 Boolean 2 Byte 2 Double 2 Float 2 Integer 2 Long 2 Short 2 Thread 2 ThreadLocal 2 Enum 3 Throwable 3 Error 3 Exception 3 Class 4 ClassLoader 4 C
JDK源码学习手册（一）
weixin_40806611的博客
08-30 1万+
JDK源码学习（准备篇） 本文为菜鸟整理文章，在学习过程中根据自己的学习过程和逻辑点将现有知识进行整合，本人玻璃心小女子一枚，新手上路，可以接收指教，但不接受指点，谢谢！ 准备篇包含以下内容 1.jdk7的源码下载 2.源码的目录解析 3.源码的阅读顺序 jdk7源码的下载路径 http://download.java.net/openjdk/jdk7/promoted...
原子类型：AtomicReference详解
热门推荐
wyaoyao93的博客
04-19 4万+
文章目录1 AtomicReferencey引入2 AtomicReference的基本用法2.1 AtomicReference的构造2.2 方法 1 AtomicReferencey引入 AtomicReference类提供了对象引用的非阻塞原子性读写操作，并且提供了其他一些高级的用法 对象的引用其实是一个4字节的数字，代表着在JVM堆内存中的引用地址，对一个4字节数字的读取操作和写入操作本身就是原子性的**，通常情况下，我们对对象引用的操作一般都是获取该引用或者重新赋值（写入操作），我们也没有办法对对
AtomicReference详解
不定期更新Java相关的各种内容
06-20 1万+
在开发中突然看到这个类，就学习了以下AtomicReference，希望可以帮到你
深度解析AtomicReference：从API到底层实现的完全指南
最新发布
weixin_51786043的博客
04-23 989
在多线程环境中，对象引用的原子更新是并发编程的痛点之一。传统`synchronized`关键字虽然能保证原子性，但会带来严重的性能损耗。Java 5引入的`AtomicReference`通过硬件级别的CAS（Compare and Swap）指令，实现了真正的无锁并发控制。
高并发编程之AtomicReference原子类讲解
weixin_45080272的博客
12-08 4538
高并发编程之Atomic原子类讲解
并发编程 — 原子类 AtomicReference 详解
small_love的专栏
12-12 1万+
通过对 AtomicInteger、AtomicBoolean 和 AtomicLong 分析我们发现，这三个原子类只能对单个变量进行原子操作，那么我们如果要对多个变量进行原子操作，这三个类就无法实现了。那如果要进行多个变量进行原子操作呢？操作方式就是，先把 多个变量封装成一个类，然后通过 AtomicReference 进行操作。 众所周知，对象的引用其实是一个4字节的数字，代表着在JVM堆内存中的引用地址，对一个4字节数字的读取操作和写入操作本身就是原子性的，通常情况下，我们对对象引用的操作一般都是获
JDK源码，整合所有内容
09-05
**JDK源码详解** JDK（Java Development Kit）是Oracle公司发布的用于开发Java应用程序的软件开发工具包，其中包含了Java运行环境、编译器、类库以及各种工具。JDK1.8版本是Java历史上的一个重要里程碑，引入了许多...
jdk1.8源码
11-21
《深入解析JDK1.8源码》 JDK（Java Development Kit）是Java开发工具集，是Java语言的核心组成部分，包含了编译器、运行环境、调试工具等。...对于想要成为Java高级开发者的人来说，研究JDK源码是一项必不可少的任务。
14.JDK底层Unsafe类是个啥东西？
chenzengnian123的博客
01-25 1234
JDK底层的unsafe是什么？竟然这么牛逼，直接申请内存、释放内存、修改内存数据、cas操作、线程挂起和唤醒、内存屏障....
原子类 AtomicReference 详解
javajy的博客
03-31 2183
通过对 AtomicInteger、AtomicBoolean 和 AtomicLong 分析我们发现，这三个原子类只能对单个变量进行原子操作，那么我们如果要对多个变量进行原子操作，这三个类就无法实现了。那如果要进行多个变量进行原子操作呢？操作方式就是，先把 多个变量封装成一个类，然后通过 AtomicReference 进行操作。
java：AtomicReference使用
a232884c的博客
10-25 5171
AtomicReference源码可知，本质是使用CAS方法+自旋更新引用对象value（AtomicReference是泛型类，V value代表引用对象），如getAndUpdate、updateAndGet、getAndAccumulate、accumulateAndGet方法。因为CAS利用CPU指令保证了操作的原子性（更新安全可靠），达到了锁的效果，而自旋则是采用循环的方式尝试获取锁，当线程发现锁被占用，会循环判断锁状态，直至获取锁。
java学习之 AtomicReference 用法和源码分析
白话机器学习
08-29 690
此篇文章主要介绍了 AtomicReference 的出现背景，AtomicReference 的使用场景，以及介绍了 AtomicReference 的源码，重点方法的源码分析。
AtomicReference
WaaTong的博客
01-24 1122
是 Java 中 java.util.concurrent.atomic包下提供的原子引用类。它用于在多线程环境下原子性地更新。与类似，AtomicReference的实现也基于（Compare-And-Swap）操作。
AtomicReference原子引用类-线程安全
yjj1123456的博客
11-25 832
是Java中的一个原子类，它的主要作用是提供了一种原子操作的方式来更新对象的引用。它通常用于多线程环境下，用来解决并发访问共享对象时可能出现的竞态条件问题。（实际开发中用于某个数据模型更新，确保一致性和线程安全，多个线程同时更新只有一个线程能够成功执行，其它线程需要等待后继续尝试更新，例如:计算总分(获取答题表分数)并更新到答案表中）AtomicReference可以确保在多线程环境下，对对象引用的更新操作是原子的，即要么更新成功，要么失败，不存在中间状态。
Java多线程进阶（13）—— J.U.C之atomic框架：AtomicReference
smart_an的专栏
02-19 1718
AtomicReference，顾名思义，就是以原子方式更新对象引用。可以看到，AtomicReference持有一个对象的引用——value为什么需要AtomicReference？难道多个线程同时对一个引用变量赋值也会出现并发问题？引用变量的赋值本身没有并发问题，也就是说对于引用变量var ，类似下面的赋值操作本身就是原子操作:AtomicReference的引入是为了可以用一种类似乐观锁的方式操作共享资源，在某些情景下以提升性能。try{// 操作共享资源sharedValue。
四、原子操作之 AtomicReference
jysf98746的博客
10-13 745
引用就是为对象另起一个名字，引用对象本身指向被引用对象，对引用对象的操作都会反映到被引用对象上。包中还提供了更多更细场景的原子操作类，此包下的大部分工具类都是基于 CAS 原理实现，正因为如此，有很多相似之处，用法大同小异，希望大家在日常研发中多比较多总结，早日掌握之。工具类实现生活中汽车牌照竞拍的例子：假设总共有 10 位客户参与竞拍，每位客户只有一次竞拍机会，竞拍是资格竞拍不以竞拍价格为目的。则是对普通的对象引用的封装，可将多个变量作为一个整体对象，操控多个属性的原子性的并发类。
Java多线程进阶（十四）—— J.U.C之atomic框架：AtomicReference
weixin_34112181的博客
07-31 319
本文首发于一世流云的专栏：https://segmentfault.com/blog... 一、AtomicReference简介 AtomicReference，顾名思义，就是以原子方式更新对象引用。 可以看到，AtomicReference持有一个对象的引用——value，并通过Unsafe类来操作该引用: 为什么需要Atom...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

至真源

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值