JavaGuide项目解析：深入理解Java原子类(Atomic Classes)

田子蜜Robust

于 2025-05-30 09:02:49 发布

阅读量395

点赞数 4

本文链接：https://blog.csdn.net/gitblog_00704/article/details/148323506

版权

JavaGuide项目解析：深入理解Java原子类(Atomic Classes)

JavaGuide JavaGuide：这是一份Java学习与面试指南，它涵盖了Java程序员所需要掌握的大部分核心知识。这份指南是一份通俗易懂、风趣幽默的学习资料，内容全面，深受Java学习者的欢迎。项目地址: https://gitcode.com/gh_mirrors/ja/JavaGuide

什么是原子类？

在并发编程中，原子性是一个核心概念。原子操作指的是不可分割的操作，要么全部执行成功，要么完全不执行，不会出现执行到一半的状态。Java中的java.util.concurrent.atomic包提供了一系列原子类，它们能够保证对单个变量的操作是原子性的。

原子类的实现基于CAS(Compare-And-Swap)机制，这是一种乐观锁策略，相比传统的synchronized同步锁，它在很多场景下能提供更好的性能。

原子类的分类

Java中的原子类可以分为四大类：

1. 基本类型原子类

用于原子性地操作基本数据类型：

AtomicInteger：整型原子类
AtomicLong：长整型原子类
AtomicBoolean：布尔型原子类

以AtomicInteger为例，它提供了以下常用方法：

// 获取当前值
public final int get()

// 获取当前值并设置新值
public final int getAndSet(int newValue)

// 获取当前值并自增
public final int getAndIncrement()

// 获取当前值并自减
public final int getAndDecrement()

// 获取当前值并加上指定值
public final int getAndAdd(int delta)

// CAS操作：如果当前值等于expect，则设置为update
boolean compareAndSet(int expect, int update)

// 延迟设置新值
public final void lazySet(int newValue)

2. 数组类型原子类

用于原子性地操作数组中的元素：

AtomicIntegerArray：整型数组原子类
AtomicLongArray：长整型数组原子类
AtomicReferenceArray：引用类型数组原子类

这些类提供了与基本类型原子类类似的方法，但针对数组中的特定元素进行操作。

3. 引用类型原子类

用于原子性地操作引用类型：

AtomicReference：普通引用类型原子类
AtomicStampedReference：带版本号的引用类型原子类
AtomicMarkableReference：带标记位的引用类型原子类

后两种主要用于解决CAS操作中的ABA问题。

4. 字段更新原子类

用于原子性地更新对象的字段：

AtomicIntegerFieldUpdater：整型字段更新器
AtomicLongFieldUpdater：长整型字段更新器
AtomicReferenceFieldUpdater：引用类型字段更新器

使用这些类时需要注意：

字段必须是volatile修饰的
字段不能是private的
字段不能是static的

原子类的核心原理

所有原子类的实现都基于CAS机制。CAS包含三个操作数：内存位置(V)、预期原值(A)和新值(B)。当且仅当V的值等于A时，CAS才会将V的值更新为B，否则不做任何操作。

CAS的优点：

避免了传统锁的性能开销
减少了线程阻塞和上下文切换

CAS的缺点：

ABA问题：一个值从A变成B又变回A，CAS会认为它没有被修改过。解决方案是使用AtomicStampedReference引入版本号。
循环时间长开销大：如果CAS长时间不成功，CPU会持续循环。
只能保证一个共享变量的原子操作。

实际应用示例

计数器实现

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();
    }
    
    public int getCount() {
        return count.get();
    }
}

无锁栈实现

public class ConcurrentStack<E> {
    private AtomicReference<Node<E>> top = new AtomicReference<>();
    
    public void push(E item) {
        Node<E> newHead = new Node<>(item);
        Node<E> oldHead;
        do {
            oldHead = top.get();
            newHead.next = oldHead;
        } while (!top.compareAndSet(oldHead, newHead));
    }
    
    public E pop() {
        Node<E> oldHead;
        Node<E> newHead;
        do {
            oldHead = top.get();
            if (oldHead == null) return null;
            newHead = oldHead.next;
        } while (!top.compareAndSet(oldHead, newHead));
        return oldHead.item;
    }
    
    private static class Node<E> {
        final E item;
        Node<E> next;
        
        Node(E item) {
            this.item = item;
        }
    }
}