JDK 8 AtomicInteger 源码详解（详细注释版）
1. 类定义和基本属性
public class AtomicInteger extends Number implements java.io.Serializable {
// 序列化版本号
private static final long serialVersionUID = 6214790243416807050L;
/**
* Unsafe类实例，提供底层的原子操作
* 通过Unsafe可以直接操作内存地址，实现CAS等原子操作
*/
private static final sun.misc.Unsafe unsafe = getUnsafe();
/**
* value字段在对象中的偏移量
* 通过这个偏移量可以使用Unsafe直接操作value字段的内存地址
* 这是实现原子操作的关键
*/
private static final long valueOffset;
/**
* 静态初始化块，获取value字段的偏移量
* 在类加载时执行，确保偏移量的正确性
*/
static {
try {
// 获取value字段的偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) {
throw new Error(ex);
}
}
/**
* 获取Unsafe实例的方法
* 由于Unsafe类的特殊性，需要通过反射获取实例
* @return Unsafe实例
*/
private static sun.misc.Unsafe getUnsafe() {
try {
return sun.misc.Unsafe.getUnsafe();
} catch (SecurityException se) {
try {
return java.security.AccessController.doPrivileged
(new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
public sun.misc.Unsafe run() throws Exception {
Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
for (java.lang.reflect.Field f : k.getDeclaredFields()) {
f.setAccessible(true);
Object x = f.get(null);
if (k.isInstance(x))
return k.cast(x);
}
throw new NoSuchFieldError("the Unsafe");
}});
} catch (java.security.PrivilegedActionException e) {
throw new RuntimeException("Could not initialize intrinsics",
e.getCause());
}
}
}
/**
* 实际存储的int值
* 使用volatile修饰确保内存可见性
* 所有原子操作都是针对这个字段进行的
*/
private volatile int value;
/**
* 默认构造方法
* 创建一个初始值为0的AtomicInteger
*
* 初始化过程：
* 1. value字段被初始化为0（int的默认值）
* 2. volatile语义确保对其他线程的可见性
*/
public AtomicInteger() {
}
/**
* 指定初始值的构造方法
* @param initialValue 初始值
*
* 初始化过程：
* 1. value字段被设置为指定的初始值
* 2. volatile语义确保对其他线程的可见性
*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/**
* 获取当前值
* 由于value字段是volatile的，这个方法保证返回最新的值
*
* 时间复杂度：O(1)
* 线程安全性：完全线程安全
*
* @return 当前值
*/
public final int get() {
return value;
}
/**
* 设置新值
* 这个操作不是原子的，只是简单地设置新值
*
* 注意事项：
* - 这个方法不保证原子性
* - 如果需要原子性设置，应该使用compareAndSet方法
* - volatile语义确保新值对其他线程可见
*
* @param newValue 新值
*/
public final void set(int newValue) {
value = newValue;
}
/**
* 最终设置新值
* 这个方法确保在方法返回之前，新值对其他线程可见
*
* 与set方法的区别：
* - lazySet可能延迟设置，提高性能
* - setImmediately确保立即设置
*
* @param newValue 新值
*/
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
/**
* 原子地设置新值并返回旧值
* 这是一个原子操作，保证读取和设置的原子性
*
* 操作过程：
* 1. 读取当前值
* 2. 设置新值
* 3. 返回旧值
*
* 时间复杂度：O(1)
* 线程安全性：完全原子性
*
* @param newValue 新值
* @return 旧值
*/
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
/**
* 原子地比较并设置值
* 只有当当前值等于期望值时，才设置为新值
*
* 操作过程：
* 1. 比较当前值和期望值
* 2. 如果相等，将当前值设置为新值
* 3. 返回比较结果
*
* CAS操作特点：
* - 无锁操作，性能优秀
* - 乐观锁机制，避免阻塞
* - 可能出现ABA问题
*
* 时间复杂度：O(1)
* 线程安全性：完全原子性
*
* @param expect 期望值
* @param update 新值
* @return 如果设置成功返回true，否则返回false
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 弱原子地比较并设置值
* 与compareAndSet类似，但在某些平台上可能不提供完全的内存排序保证
*
* 使用场景：
* - 对内存排序要求不严格的场景
* - 性能要求极高的场景
*
* @param expect 期望值
* @param update 新值
* @return 如果设置成功返回true，否则返回false
*/
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
2. 原子更新方法（详细注释）
/**
* 原子地增加1并返回旧值
* 这是一个原子的自增操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算新值（当前值+1）
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回旧值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @return 增加前的值
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
* 原子地减少1并返回旧值
* 这是一个原子的自减操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算新值（当前值-1）
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回旧值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @return 减少前的值
*/
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
/**
* 原子地增加指定值并返回旧值
* 这是一个原子的加法操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算新值（当前值+delta）
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回旧值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param delta 要增加的值
* @return 增加前的值
*/
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
/**
* 原子地增加1并返回新值
* 这是一个原子的自增操作
*
* 与getAndIncrement的区别：
* - getAndIncrement返回旧值
* - incrementAndGet返回新值
*
* 操作过程：
* 1. 获取当前值
* 2. 计算新值（当前值+1）
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @return 增加后的值
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
/**
* 原子地减少1并返回新值
* 这是一个原子的自减操作
*
* 与getAndDecrement的区别：
* - getAndDecrement返回旧值
* - decrementAndGet返回新值
*
* 操作过程：
* 1. 获取当前值
* 2. 计算新值（当前值-1）
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @return 减少后的值
*/
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
/**
* 原子地增加指定值并返回新值
* 这是一个原子的加法操作
*
* 与getAndAdd的区别：
* - getAndAdd返回旧值
* - addAndGet返回新值
*
* 操作过程：
* 1. 获取当前值
* 2. 计算新值（当前值+delta）
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param delta 要增加的值
* @return 增加后的值
*/
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
/**
* 原子地更新值，使用指定的更新函数
* 这是Java 8新增的方法，支持函数式编程
*
* 操作过程：
* 1. 获取当前值
* 2. 使用updateFunction计算新值
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param updateFunction 更新函数
* @return 更新后的值
*/
public final int updateAndGet(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return next;
}
/**
* 原子地更新值，使用指定的更新函数
* 返回更新前的值
*
* 操作过程：
* 1. 获取当前值
* 2. 使用updateFunction计算新值
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回旧值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param updateFunction 更新函数
* @return 更新前的值
*/
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 原子地累积值，使用指定的累积函数
* 这是Java 8新增的方法，支持累积操作
*
* 操作过程：
* 1. 获取当前值
* 2. 使用accumulatorFunction计算累积值
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param x 要累积的值
* @param accumulatorFunction 累积函数
* @return 累积后的值
*/
public final int accumulateAndGet(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return next;
}
/**
* 原子地累积值，使用指定的累积函数
* 返回累积前的值
*
* 操作过程：
* 1. 获取当前值
* 2. 使用accumulatorFunction计算累积值
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回旧值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param x 要累积的值
* @param accumulatorFunction 累积函数
* @return 累积前的值
*/
public final int getAndAccumulate(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return prev;
}
3. Number类方法实现（详细注释）
/**
* 以int形式返回值
* 继承自Number类，用于类型转换
*
* @return int值
*/
public int intValue() {
return get();
}
/**
* 以long形式返回值
* 继承自Number类，用于类型转换
*
* @return long值
*/
public long longValue() {
return (long)get();
}
/**
* 以float形式返回值
* 继承自Number类，用于类型转换
*
* @return float值
*/
public float floatValue() {
return (float)get();
}
/**
* 以double形式返回值
* 继承自Number类，用于类型转换
*
* @return double值
*/
public double doubleValue() {
return (double)get();
}
4. 字符串表示方法（详细注释）
/**
* 返回对象的字符串表示
* 重写Object类的toString方法
*
* @return 当前值的字符串表示
*/
public String toString() {
return Integer.toString(get());
}
/**
* 计算当前值的哈希码
* 重写Object类的hashCode方法
*
* @return 当前值
*/
public int hashCode() {
return get();
}
/**
* 比较两个AtomicInteger对象是否相等
* 重写Object类的equals方法
*
* @param obj 要比较的对象
* @return 如果相等返回true，否则返回false
*/
public boolean equals(Object obj) {
if (obj instanceof AtomicInteger) {
return value == ((AtomicInteger)obj).value;
}
return false;
}
5. AtomicInteger 的特点分析
核心设计理念：
/**
* AtomicInteger的核心设计思想：
*
* 1. 无锁编程：
* - 使用CAS（Compare-And-Swap）操作实现原子性
* - 避免传统锁的开销和阻塞
* - 提供乐观锁机制
*
* 2. volatile语义：
* - value字段使用volatile修饰
* - 保证内存可见性
* - 确保读操作获取最新值
*
* 3. Unsafe支持：
* - 使用sun.misc.Unsafe类提供底层原子操作
* - 直接操作内存地址，性能优异
* - 绕过JVM的常规访问控制
*
* 4. 偏移量机制：
* - 通过字段偏移量直接访问内存
* - 避免反射开销
* - 提供精确的内存操作
*
* 5. 自旋重试：
* - CAS失败时自动重试
* - 保证操作的最终成功
* - 适用于竞争不激烈的场景
*
* 6. 函数式支持：
* - Java 8新增函数式更新方法
* - 支持lambda表达式
* - 提供更灵活的原子操作
*
* 适用场景：
* - 计数器实现
* - 序列号生成
* - 状态标志管理
* - 高并发环境下的简单共享变量
* - 需要原子操作的数值计算
*/
性能特征分析：
/**
* AtomicInteger的性能特征：
*
* 时间复杂度：
* - get(): O(1) - 直接读取volatile字段
* - set(): O(1) - 直接写入volatile字段
* - getAndSet(): O(1) 平均，O(∞) 最坏
* - compareAndSet(): O(1) 平均，O(∞) 最坏
* - getAndIncrement(): O(1) 平均，O(∞) 最坏
* - incrementAndGet(): O(1) 平均，O(∞) 最坏
*
* 空间复杂度：
* - O(1) - 只需要存储一个int值和偏移量
*
* 并发特性：
* - 完全线程安全
* - 无锁设计，避免线程阻塞
* - 乐观锁机制，适用于低竞争场景
* - 高竞争场景下可能出现自旋开销
*
* 与synchronized对比：
* - 无竞争：AtomicInteger > synchronized
* - 低竞争：AtomicInteger > synchronized
* - 高竞争：AtomicInteger可能 < synchronized
* - 内存开销：AtomicInteger < synchronized
*
* CAS操作特点：
* - 乐观锁：假设没有冲突，冲突时重试
* - 非阻塞：不会阻塞其他线程
* - ABA问题：需要额外机制解决
* - 自旋开销：高竞争时CPU使用率可能较高
*
* 内存使用：
* - 每个实例固定开销很小
* - volatile字段保证可见性
* - 及时GC，避免内存泄漏
*
* 适用性：
* - 简单的原子操作：性能优异
* - 高频计数场景：性能优异
* - 复杂同步逻辑：可能不如锁机制
* - 需要精确控制：比锁更灵活
*/
6. 使用示例和最佳实践
/**
* 使用示例：
*
* // 基本使用
* AtomicInteger counter = new AtomicInteger(0);
*
* // 原子自增
* int oldValue = counter.getAndIncrement(); // 返回旧值
* int newValue = counter.incrementAndGet(); // 返回新值
*
* // 原子自减
* int oldValue2 = counter.getAndDecrement();
* int newValue2 = counter.decrementAndGet();
*
* // 原子加法
* int oldValue3 = counter.getAndAdd(5);
* int newValue3 = counter.addAndGet(5);
*
* // 比较并设置
* boolean success = counter.compareAndSet(10, 20);
* if (success) {
* System.out.println("Value updated successfully");
* } else {
* System.out.println("Value update failed");
* }
*
* // 函数式更新（Java 8+）
* int result = counter.updateAndGet(x -> x * 2);
* int previous = counter.getAndUpdate(x -> x + 1);
*
* // 累积操作（Java 8+）
* int accumulated = counter.accumulateAndGet(10, Integer::sum);
* int previousAcc = counter.getAndAccumulate(5, Math::max);
*
* // 多线程计数器示例
* class ThreadSafeCounter {
* private final AtomicInteger count = new AtomicInteger(0);
*
* public void increment() {
* count.incrementAndGet();
* }
*
* public void decrement() {
* count.decrementAndGet();
* }
*
* public int getCount() {
* return count.get();
* }
*
* public boolean compareAndSetCount(int expect, int update) {
* return count.compareAndSet(expect, update);
* }
* }
*
* // 序列号生成器示例
* class SequenceGenerator {
* private final AtomicInteger sequence = new AtomicInteger(0);
*
* public int getNextSequence() {
* return sequence.incrementAndGet();
* }
*
* public int getCurrentSequence() {
* return sequence.get();
* }
*
* public void resetSequence(int newValue) {
* sequence.set(newValue);
* }
* }
*
* // 状态标志示例
* class StatusFlag {
* private final AtomicInteger status = new AtomicInteger(0);
*
* public static final int STOPPED = 0;
* public static final int RUNNING = 1;
* public static final int PAUSED = 2;
*
* public boolean start() {
* return status.compareAndSet(STOPPED, RUNNING);
* }
*
* public boolean pause() {
* return status.compareAndSet(RUNNING, PAUSED);
* }
*
* public boolean resume() {
* return status.compareAndSet(PAUSED, RUNNING);
* }
*
* public boolean stop() {
* return status.compareAndSet(RUNNING, STOPPED) ||
* status.compareAndSet(PAUSED, STOPPED);
* }
*
* public int getStatus() {
* return status.get();
* }
* }
*
* 最佳实践：
*
* 1. 正确使用原子操作：
* AtomicInteger counter = new AtomicInteger(0);
*
* // 正确的做法：使用原子操作
* counter.incrementAndGet();
*
* // 错误的做法：非原子操作
* // counter.set(counter.get() + 1); // 不是原子操作！
*
* 2. 合理使用compareAndSet：
* AtomicInteger flag = new AtomicInteger(0);
*
* // 正确使用：检查并更新
* public boolean trySetFlag(int expected, int newValue) {
* return flag.compareAndSet(expected, newValue);
* }
*
* // 错误使用：忽略返回值
* // flag.compareAndSet(0, 1); // 没有检查返回值
*
* 3. 选择合适的获取方法：
* AtomicInteger value = new AtomicInteger(0);
*
* // 当需要旧值时使用getAnd系列方法
* int oldValue = value.getAndIncrement();
* System.out.println("Old value was: " + oldValue);
*
* // 当需要新值时使用incrementAndGet等方法
* int newValue = value.incrementAndGet();
* System.out.println("New value is: " + newValue);
*
* 4. 处理CAS失败的情况：
* AtomicInteger value = new AtomicInteger(0);
*
* // 使用循环确保操作成功
* public boolean updateValue(int expected, int newValue) {
* return value.compareAndSet(expected, newValue);
* }
*
* // 或者使用函数式方法
* public int doubleValue() {
* return value.updateAndGet(x -> x * 2);
* }
*
* 5. 避免ABA问题：
* // ABA问题示例：值从A变为B再变为A
* AtomicInteger value = new AtomicInteger(10);
*
* // 线程1准备更新
* int expected = value.get(); // 获取到10
*
* // 线程2执行：10 -> 20 -> 10
* value.compareAndSet(10, 20);
* value.compareAndSet(20, 10);
*
* // 线程1执行：CAS成功，但实际上中间状态发生了变化
* value.compareAndSet(expected, 30); // 成功，但可能不是期望的行为
*
* // 解决方案：使用AtomicStampedReference
* AtomicStampedReference<Integer> stampedValue =
* new AtomicStampedReference<>(10, 0);
*
* public boolean updateWithStamp(int expected, int newValue) {
* int[] stampHolder = new int[1];
* int current = stampedValue.get(stampHolder);
* int stamp = stampHolder[0];
* return stampedValue.compareAndSet(expected, newValue, stamp, stamp + 1);
* }
*
* 6. 合理使用函数式更新：
* AtomicInteger value = new AtomicInteger(0);
*
* // 简单操作使用专门方法
* value.incrementAndGet(); // 比函数式更快
*
* // 复杂操作使用函数式方法
* int result = value.updateAndGet(x -> {
* // 复杂计算
* return complexCalculation(x);
* });
*
* 7. 监控和调试：
* AtomicInteger counter = new AtomicInteger(0);
*
* // 定期检查计数器状态
* public void logCounterStatus() {
* System.out.println("Current counter value: " + counter.get());
* }
*
* // 性能监控
* public void monitorPerformance() {
* long startTime = System.nanoTime();
* // 执行一些操作
* for (int i = 0; i < 1000000; i++) {
* counter.incrementAndGet();
* }
* long endTime = System.nanoTime();
* System.out.println("Time taken: " + (endTime - startTime) + " ns");
* }
*
* 8. 批量操作优化：
* AtomicInteger counter = new AtomicInteger(0);
*
* // 避免频繁的原子操作
* // 错误做法：每次循环都进行原子操作
* // for (int i = 0; i < 1000; i++) {
* // counter.incrementAndGet();
* // }
*
* // 正确做法：批量更新
* int batchSize = 1000;
* counter.addAndGet(batchSize);
*
* 9. 异常处理：
* AtomicInteger value = new AtomicInteger(0);
*
* public void safeUpdate(IntUnaryOperator updateFunction) {
* try {
* value.updateAndGet(updateFunction);
* } catch (Exception e) {
* System.err.println("Update failed: " + e.getMessage());
* // 记录日志或采取其他措施
* }
* }
*
* 10. 性能调优：
* // 在高并发场景下监控性能
* AtomicInteger counter = new AtomicInteger(0);
*
* // 使用ThreadLocal减少竞争
* class ThreadLocalCounter {
* private final ThreadLocal<Integer> localCounter =
* ThreadLocal.withInitial(() -> 0);
* private final AtomicInteger globalCounter = new AtomicInteger(0);
*
* public void increment() {
* int local = localCounter.get();
* if (local < 100) {
* localCounter.set(local + 1);
* } else {
* globalCounter.addAndGet(local + 1);
* localCounter.set(0);
* }
* }
*
* public int getTotal() {
* return globalCounter.get() + localCounter.get();
* }
* }
*/
7. 与其他原子类的比较
/**
* AtomicInteger vs AtomicLong vs AtomicBoolean vs AtomicReference:
*
* AtomicInteger:
* - 用于int类型的操作
* - 提供丰富的数学运算方法
* - 32位整数操作
* - 最常用的原子类
*
* AtomicLong:
* - 用于long类型的操作
* - 提供与AtomicInteger类似的方法
* - 64位整数操作
* - 适用于需要更大数值范围的场景
*
* AtomicBoolean:
* - 用于boolean类型的操作
* - 提供get/set/compareAndSet等方法
* - 适用于状态标志
* - 内存效率高
*
* AtomicReference:
* - 用于对象引用的操作
* - 支持CAS操作对象引用
* - 适用于复杂对象的原子操作
* - 可以配合AtomicStampedReference解决ABA问题
*
* 性能对比：
* - 基本操作：AtomicInteger ≈ AtomicLong > AtomicReference > AtomicBoolean
* - 内存使用：AtomicBoolean < AtomicInteger ≈ AtomicLong < AtomicReference
* - 功能丰富度：AtomicReference > AtomicInteger ≈ AtomicLong > AtomicBoolean
*
* 选择建议：
* - 简单计数：AtomicInteger
* - 大数值计数：AtomicLong
* - 状态标志：AtomicBoolean
* - 对象引用：AtomicReference
* - 需要版本控制：AtomicStampedReference
* - 需要标记引用：AtomicMarkableReference
*
* 使用场景：
* - AtomicInteger：计数器、序列号、简单的数值操作
* - AtomicLong：时间戳、大计数器、需要64位精度的场景
* - AtomicBoolean：开关、标志位、简单的状态管理
* - AtomicReference：复杂对象的原子操作、缓存引用
*/
8. 总结
AtomicInteger 的核心特性：
-
无锁原子操作：
- 使用CAS实现原子性
- 避免传统锁的开销
- 提供乐观锁机制
-
内存可见性：
- value字段使用volatile修饰
- 保证多线程间的内存可见性
- 确保读操作获取最新值
-
丰富的原子操作：
- 基本的get/set操作
- 自增自减操作
- 比较并设置操作
- 函数式更新操作（Java 8+）
-
高性能设计：
- 基于Unsafe的底层操作
- 字段偏移量直接访问
- 自旋重试机制
-
线程安全：
- 所有操作都是线程安全的
- 适用于高并发环境
- 无死锁风险
适用场景：
- 计数器实现
- 序列号生成
- 状态标志管理
- 高并发环境下的简单共享变量
- 需要原子操作的数值计算
注意事项：
- CAS操作可能出现ABA问题
- 高竞争场景下可能有自旋开销
- 不支持复合原子操作
- 需要正确处理CAS的返回值
- 注意选择合适的更新方法
性能优化建议：
- 根据数据类型选择合适的原子类
- 合理使用compareAndSet避免不必要的操作
- 在高竞争场景下考虑使用ThreadLocal减少竞争
- 监控原子操作的性能表现
- 避免频繁的原子操作，考虑批量更新
- 正确处理ABA问题（必要时使用AtomicStampedReference）
- 选择合适的获取方法（getAnd系列 vs incrementAndGet系列）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
