当前位置：首页 > article >正文

java原子操作类

article 2024/11/13 14:04:38

在并发编程中，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();
        }
    }
}