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

Java并发编程：深入解析原子操作类与CAS原理

news 来源：原创 2025/6/20 7:40:59

一、原子操作类概述

Java并发包(java.util.concurrent.atomic)提供了一系列原子操作类，这些类通过无锁算法实现了线程安全的操作，相比传统的锁机制具有更高的性能。原子类基于CAS(Compare-And-Swap)指令实现，是现代并发编程的重要基础。

原子类主要分类：

基本类型：AtomicInteger、AtomicLong、AtomicBoolean
引用类型：AtomicReference、AtomicStampedReference、AtomicMarkableReference
数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
字段更新器：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
累加器：LongAdder、DoubleAdder（JDK8+）
累加器增强：LongAccumulator、DoubleAccumulator（JDK8+）

二、CAS原理深度解析

1. CAS操作语义

CAS是一种原子指令，包含三个操作数：

内存位置(V)
预期原值(A)
新值(B)

当且仅当V的值等于A时，处理器才会将V的值更新为B，否则不执行任何操作。无论哪种情况都会返回V的当前值。

2. Java中的CAS实现

Java通过Unsafe类提供CAS操作支持：

public final class Unsafe {
    public final native boolean compareAndSwapInt(
        Object o, long offset, int expected, int x);
    
    public final native boolean compareAndSwapLong(
        Object o, long offset, long expected, long x);
    
    public final native boolean compareAndSwapObject(
        Object o, long offset, Object expected, Object x);
}

3. CAS的三大问题

ABA问题：值从A变为B又变回A，CAS会认为没变化
- 解决方案：使用AtomicStampedReference添加版本号
循环时间长开销大：CAS失败会自旋重试，消耗CPU
- 解决方案：JVM支持pause指令降低CPU消耗
只能保证一个变量的原子操作
- 解决方案：使用AtomicReference保证多个变量的原子性

三、核心原子类实现分析

1. AtomicInteger源码解析

public class AtomicInteger extends Number {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    private volatile int value;
    
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    
    // Unsafe中的实现
    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }
}

2. LongAdder高性能原理

设计思想：分段CAS，减少竞争

内部维护一个Cell数组和base值
线程首先尝试更新base值
竞争激烈时，线程会分配到不同的Cell上进行更新
最终结果为base+∑Cell[i]

适用场景：高并发统计计数，不保证实时精确

四、原子类的典型应用

1. 计数器实现

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

2. 单例模式优化

public class Singleton {
    private static final AtomicReference<Singleton> INSTANCE = 
        new AtomicReference<>();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        for (;;) {
            Singleton instance = INSTANCE.get();
            if (instance != null) {
                return instance;
            }
            instance = new Singleton();
            if (INSTANCE.compareAndSet(null, instance)) {
                return instance;
            }
        }
    }
}

3. 状态标志管理

public class StatusManager {
    private final AtomicBoolean status = new AtomicBoolean(false);
    
    public void enable() {
        status.set(true);
    }
    
    public boolean tryDisable() {
        return status.compareAndSet(true, false);
    }
}

五、原子类性能优化

1. 伪共享(False Sharing)问题

问题描述：多个线程修改同一缓存行的不同变量，导致性能下降

解决方案：

JDK8使用@Contended注解自动填充（需开启JVM参数）
手动填充（对于非JDK8或特定场景）

public class PaddedAtomicLong extends AtomicLong {
    public volatile long p1, p2, p3, p4, p5, p6 = 7L; // 填充
    
    public PaddedAtomicLong(long initialValue) {
        super(initialValue);
    }
}

2. 计数器选型建议

场景	推荐类	原因
低竞争环境	AtomicLong	实现简单，开销小
高并发写入	LongAdder	分段减少竞争，吞吐量高
需要复杂累加操作	LongAccumulator	支持自定义累加函数