Java原子类详解：实现高效无锁并发操作

原子操作的核心原理

原子类的核心优势在于它们利用了底层硬件提供的CAS指令，能够在单步操作中完成“读取值-判断值-更新值”的动作，且该过程不会被线程调度中断。相较于重量级的锁机制，原子类在低竞争场景下能显著降低CPU占用率并提高吞吐量。以下是四类主要原子操作类的具体应用场景：

第1步：基本类型的原子操作

AtomicInteger是最常用的原子类之一，适用于需要对单个整型变量进行原子递增、递减或条件更新的场景。它提供了丰富的方法来处理常见的并发需求，如先自增后返回旧值、先自增后返回新值等。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicBasicTest {
    public static void main(String[] args) {
        // 模拟售票场景，初始票数100张
        AtomicTicket ticket = new AtomicTicket();
        
        // 创建3个线程模拟并发抢票
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                while (ticket.getCount() > 0) {
                    System.out.println(Thread.currentThread().getName() + " count: " + ticket.decrement());
                }
            }, "Thread-" + i).start();
        }
    }
}

class AtomicTicket {
    private AtomicInteger count = new AtomicInteger(100);

    /**
     * getAndDecrement: 先获取当前值，然后原子性减1，返回的是变化前的数据。
     * 这种方式避免了非原子操作中的竞态条件（Race Condition）。
     */
    public int decrement() {
        return count.getAndDecrement();
    }

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

上述代码通过getAndDecrement()确保了即使多个线程同时调用，每个线程拿到的票数也是唯一且准确的，不会出现超卖现象。

第2步：数组元素的原子更新

当需要同时对多个相关数据进行原子操作时，可以使用AtomicIntegerArray。与基础类型不同，数组类的操作方法必须指定索引位置。这在维护一组计数器或状态标志时非常有用。

import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class AtomicArrayTest {
    // 初始化一个包含1-10的数组
    private final static AtomicIntegerArray ATOMIC_INTEGER_ARRAY = new AtomicIntegerArray(new int[]{1,2,3,4,5,6,7,8,9,10});

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        
        // 启动10个线程，每个线程更新对应索引位置的元素
        for(int i = 0; i < 10; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                // get(index): 获取原值
                // addAndGet(index, index + 1): 将索引为index的元素增加(index+1)，并返回新值
                int original = ATOMIC_INTEGER_ARRAY.get(index);
                int result = ATOMIC_INTEGER_ARRAY.addAndGet(index, index + 1);
                System.out.println("Thread: " + Thread.currentThread().getName() 
                    + " , Original: " + original + " , New: " + result);
            });
            threads[i].start();
        }
        
        // 等待所有线程结束
        for(Thread thread : threads) {
            thread.join();
        }
        
        System.out.println("\n最终结果列表:");
        for(int i = 0; i < ATOMIC_INTEGER_ARRAY.length(); i++) {
            System.out.println(ATOMIC_INTEGER_ARRAY.get(i));
        }
    }
}

这里使用了addAndGet，它会原子地将指定下标的值加上偏移量并返回更新后的值，保证了多线程环境下数组元素的精确修改。

第3步：复杂引用的原子交换

AtomicReference用于对对象引用的原子化操作，特别适用于缓存刷新、状态机等需要整体替换对象的场景。其核心方法是compareAndSet(expected, update)，只有当当前引用等于期望值时才更新为新引用。

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        People p1 = new People("Bom", 0);
        People p2 = new People("Tom", 10);
        
        // 初始化引用
        AtomicReference ref = new AtomicReference<>(p1);
        
        // compareAndSet: 如果当前值为p1，则更新为p2，返回true；否则不更新返回false
        boolean success = ref.compareAndSet(p1, p2);
        System.out.println("Update Status: " + success); // true
        System.out.println("Current Ref: " + ref.get());
        
        // 模拟并发更新，利用getAndSet原子地交换引用
        // 注意：这里仅演示单次交换，实际应用中需处理不可变对象或深层拷贝
        ref.getAndSet(new People("Jerry", 20));
        System.out.println("Updated Ref: " + ref.get());
    }
}

class People {
    private String name;
    private int age;
    // Getters and Setters omitted for brevity
    public People(String name, int age) { this.name = name; this.age = age; }
    @Override
    public String toString() { return "People{" + name + ", " + age + "}"; }
}

在使用引用原子类时，务必确保对象本身的不可变性（Immutable）或正确使用深拷贝，否则修改被引用对象的内部属性不会影响CAS的判断结果。

第4步：特定字段的原子更新

在某些情况下，我们希望直接原子性地修改某个类中特定字段的值，而不需要包装整个对象。AtomicIntegerFieldUpdater允许我们通过反射机制，以静态工厂方式创建一个“场更新器”，从而对类中特定的volatile整型字段进行原子操作。

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class FieldUpdaterDemo {
    // 创建更新器，第一个参数是类，第二个参数是要操作的字段名
    private static final AtomicIntegerFieldUpdater UPDATER = 
        AtomicIntegerFieldUpdater.newUpdater(Account.class, "balance");

    public static void main(String[] args) {
        Account account = new Account();
        
        // 原子增加余额
        UPDATER.addAndGet(account, 100);
        System.out.println("Balance after add: " + UPDATER.get(account));
        
        // CAS操作：如果余额等于100，则设置为500
        if (UPDATER.compareAndSet(account, 100, 500)) {
            System.out.println("CAS Success. New Balance: " + UPDATER.get(account));
        }
    }
}

class Account {
    // 关键字段必须是 volatile，这是FieldUpdater的要求
    public volatile int balance = 0;
    public volatile String name = "Initial";
}

注意：AtomicIntegerFieldUpdater有严格的使用限制：字段必须是volatile类型，且不能是static或final。这要求开发者在设计类结构时预留好并发访问的字段。

总结

Java原子类是构建高性能并发程序的基石。通过合理选择AtomicInteger、AtomicIntegerArray、AtomicReference和各类Updater，开发者可以在无需加锁的前提下解决大多数共享变量的同步问题。但在高竞争场景下，原子类可能会因频繁的CAS失败导致CPU空转，此时应考虑引入分段锁或更高级的并发工具类（如LongAdder）。以上就是Java原子类详细用法及多场景实战的内容，更多关于Java并发优化的资料请关注本站其它相关文章！