java原子操作类

在并发编程中，Java 提供了一组原子操作类来确保线程安全，这些类位于 java.util.concurrent.atomic 包中。这些类通过底层硬件支持的CAS（Compare-And-Swap，比较并交换）机制，能够在无锁的情况下实现对变量的安全更新。这种无锁机制不仅能确保线程安全，还能避免传统锁带来的上下文切换开销，极大提高了并发性能。

1. 原子操作的背景

在多线程编程中，多个线程可能同时操作共享的变量。如果不使用同步机制（如 synchronized 或 Lock），多个线程的并发修改可能导致数据不一致的情况。为了解决这个问题，Java 提供了 Atomic 类，它们支持一种非阻塞的原子性操作。

原子性：是指在一次操作过程中，中间不会被其他线程打断，保证操作的完整性。
CAS：原子操作类依赖 CAS 实现线程安全，CAS 是一种乐观锁机制，它比较当前变量的值与预期值，如果相等就更新，否则重试。这种机制通常会比阻塞锁更加高效。

2. 原子操作类的分类

Java 提供了多种原子操作类，主要分为以下几类：

原子更新基本类型：
- AtomicInteger：对 int 类型的原子操作。
- AtomicLong：对 long 类型的原子操作。
- AtomicBoolean：对 boolean 类型的原子操作。
原子更新数组类型：
- AtomicIntegerArray：对 int[] 数组的原子操作。
- AtomicLongArray：对 long[] 数组的原子操作。
- AtomicReferenceArray<E>：对对象数组的原子操作。
原子更新引用类型：
- AtomicReference<V>：对普通对象引用的原子操作。
- AtomicStampedReference<V>：带有版本戳的原子引用，可以解决 ABA 问题。
- AtomicMarkableReference<V>：带有标记位的原子引用。
原子更新对象属性类型：
- AtomicIntegerFieldUpdater<T>：对 int 类型的某个类的字段进行原子更新。
- AtomicLongFieldUpdater<T>：对 long 类型的某个类的字段进行原子更新。
- AtomicReferenceFieldUpdater<T,V>：对对象引用类型的某个类的字段进行原子更新。

3. 常用原子操作类详解

3.1 AtomicInteger

AtomicInteger 是最常用的原子操作类之一，它用于对 int 类型的变量进行原子更新。常见的方法包括：

get()：获取当前值。
set(int newValue)：设置新值。
compareAndSet(int expect, int update)：如果当前值等于 expect，则将其更新为 update。
getAndIncrement()：以原子方式将当前值加 1，并返回旧值。
incrementAndGet()：以原子方式将当前值加 1，并返回新值。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;public class AtomicIntegerExample {private static final AtomicInteger counter = new AtomicInteger(0);public static void main(String[] args) {// 多线程并发递增for (int i = 0; i < 10; i++) {new Thread(() -> {int newValue = counter.incrementAndGet(); // 原子递增System.out.println(Thread.currentThread().getName() + " - Counter: " + newValue);}).start();}}
}

在上面的代码中，多个线程可以并发递增 counter，且不需要使用锁来保证线程安全，因为 AtomicInteger 使用 CAS 实现了无锁的原子性递增。

3.2 AtomicReference

AtomicReference 用于对引用类型（对象）的原子更新。它与 AtomicInteger 类似，但操作的是对象而非基本类型。常用方法包括：

get()：获取当前对象的引用。
set(V newValue)：设置新引用。
compareAndSet(V expect, V update)：如果当前引用等于 expect，则将其更新为 update。

示例代码：

import java.util.concurrent.atomic.AtomicReference;public class AtomicReferenceExample {private static final AtomicReference<String> ref = new AtomicReference<>("Initial Value");public static void main(String[] args) {// 多线程并发更新引用for (int i = 0; i < 3; i++) {new Thread(() -> {String oldValue = ref.get();String newValue = oldValue + " Updated by " + Thread.currentThread().getName();if (ref.compareAndSet(oldValue, newValue)) {System.out.println(Thread.currentThread().getName() + " - Updated: " + newValue);} else {System.out.println(Thread.currentThread().getName() + " - Update failed");}}).start();}}
}

这个示例展示了如何使用 AtomicReference 来保证多个线程并发更新对象引用时的原子性。compareAndSet 方法确保只有预期的引用被更新，避免了并发修改问题。

3.3 AtomicStampedReference

AtomicStampedReference 是 AtomicReference 的扩展，它解决了ABA 问题。ABA 问题是指在并发环境中，一个变量可能被修改为旧值，然后再次被修改回来，但这个变化可能会被忽略，因为在 CAS 比较时，值没有发生变化。AtomicStampedReference 通过为每次操作打上“戳”，来检测是否出现 ABA 问题。

示例代码：

import java.util.concurrent.atomic.AtomicStampedReference;public class AtomicStampedReferenceExample {private static final AtomicStampedReference<String> stampedRef = new AtomicStampedReference<>("Initial", 0);public static void main(String[] args) {int[] stampHolder = new int[1];String oldValue = stampedRef.get(stampHolder); // 获取当前值和戳int stamp = stampHolder[0]; // 当前戳System.out.println("Old Value: " + oldValue + ", Stamp: " + stamp);// 更新值和戳boolean result = stampedRef.compareAndSet(oldValue, "Updated", stamp, stamp + 1);if (result) {System.out.println("Update success. New Value: " + stampedRef.getReference() + ", New Stamp: " + stampedRef.getStamp());} else {System.out.println("Update failed.");}}
}

在这个示例中，AtomicStampedReference 通过戳来解决了 ABA 问题。每次修改时都会比较值和戳，确保引用的值和版本戳同时满足预期。

3.4 AtomicIntegerArray

AtomicIntegerArray 是对 int 数组的原子操作类。它支持对数组中每个元素进行原子操作，而不需要对整个数组加锁。常见的方法包括：

get(int i)：获取数组第 i 个元素的值。
set(int i, int newValue)：设置第 i 个元素的新值。
getAndIncrement(int i)：将数组第 i 个元素加 1，并返回旧值。

示例代码：

import java.util.concurrent.atomic.AtomicIntegerArray;public class AtomicIntegerArrayExample {private static final AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);public static void main(String[] args) {// 启动多个线程操作数组for (int i = 0; i < 5; i++) {int index = i;new Thread(() -> {int oldValue = atomicArray.getAndIncrement(index);System.out.println(Thread.currentThread().getName() + " - Index: " + index + ", Old Value: " + oldValue + ", New Value: " + atomicArray.get(index));}).start();}}
}