JDK 8 AtomicBoolean 源码详解（详细注释版）
1. 类定义和基本属性
public class AtomicBoolean implements java.io.Serializable {
// 序列化版本号
private static final long serialVersionUID = 4654671469794556979L;
/**
* 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
(AtomicBoolean.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值（不是boolean）
* 使用volatile修饰确保内存可见性
* 使用int而不是boolean是为了与Unsafe的操作兼容
* 1表示true，0表示false
*/
private volatile int value;
/**
* 默认构造方法
* 创建一个初始值为false的AtomicBoolean
*
* 初始化过程：
* 1. value字段被初始化为0（int的默认值，表示false）
* 2. volatile语义确保对其他线程的可见性
*/
public AtomicBoolean() {
}
/**
* 指定初始值的构造方法
* @param initialValue 初始值
*
* 初始化过程：
* 1. value字段被设置为初始值对应的int值（true为1，false为0）
* 2. volatile语义确保对其他线程的可见性
*/
public AtomicBoolean(boolean initialValue) {
value = initialValue ? 1 : 0;
}
/**
* 获取当前值
* 将int值转换为boolean值返回
* 由于value字段是volatile的，这个方法保证返回最新的值
*
* 时间复杂度：O(1)
* 线程安全性：完全线程安全
*
* @return 当前boolean值
*/
public final boolean get() {
return value != 0;
}
/**
* 设置新值
* 这个操作不是原子的，只是简单地设置新值
*
* 注意事项：
* - 这个方法不保证原子性
* - 如果需要原子性设置，应该使用compareAndSet方法
* - volatile语义确保新值对其他线程可见
*
* @param newValue 新值
*/
public final void set(boolean newValue) {
value = newValue ? 1 : 0;
}
/**
* 最终设置新值
* 这个方法确保在方法返回之前，新值对其他线程可见
*
* 与set方法的区别：
* - lazySet可能延迟设置，提高性能
* - setImmediately确保立即设置
*
* @param newValue 新值
*/
public final void lazySet(boolean newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue ? 1 : 0);
}
/**
* 原子地设置新值并返回旧值
* 这是一个原子操作，保证读取和设置的原子性
*
* 操作过程：
* 1. 读取当前值
* 2. 设置新值
* 3. 返回旧值
*
* 时间复杂度：O(1)
* 线程安全性：完全原子性
*
* @param newValue 新值
* @return 旧值
*/
public final boolean getAndSet(boolean newValue) {
boolean prev;
do {
prev = get();
} while (!compareAndSet(prev, newValue));
return prev;
}
/**
* 原子地比较并设置值
* 只有当当前值等于期望值时，才设置为新值
*
* 操作过程：
* 1. 比较当前值和期望值
* 2. 如果相等，将当前值设置为新值
* 3. 返回比较结果
*
* CAS操作特点：
* - 无锁操作，性能优秀
* - 乐观锁机制，避免阻塞
* - 对于boolean类型，ABA问题不会出现
*
* 时间复杂度：O(1)
* 线程安全性：完全原子性
*
* @param expect 期望值
* @param update 新值
* @return 如果设置成功返回true，否则返回false
*/
public final boolean compareAndSet(boolean expect, boolean update) {
int e = expect ? 1 : 0;
int u = update ? 1 : 0;
return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}
/**
* 弱原子地比较并设置值
* 与compareAndSet类似，但在某些平台上可能不提供完全的内存排序保证
*
* 使用场景：
* - 对内存排序要求不严格的场景
* - 性能要求极高的场景
*
* @param expect 期望值
* @param update 新值
* @return 如果设置成功返回true，否则返回false
*/
public final boolean weakCompareAndSet(boolean expect, boolean update) {
int e = expect ? 1 : 0;
int u = update ? 1 : 0;
return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}
2. 逻辑操作方法（详细注释）
/**
* 原子地进行逻辑与操作并返回旧值
* 将当前值与给定值进行逻辑与操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算逻辑与结果
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回旧值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param x 要进行逻辑与操作的值
* @return 操作前的值
*/
public final boolean getAndSet(boolean x) {
boolean prev;
do {
prev = get();
} while (!compareAndSet(prev, x));
return prev;
}
/**
* 原子地进行逻辑与操作并返回新值
* 将当前值与给定值进行逻辑与操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算逻辑与结果
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param x 要进行逻辑与操作的值
* @return 操作后的值
*/
public final boolean andAndGet(boolean x) {
boolean prev, next;
do {
prev = get();
next = prev & x;
} while (!compareAndSet(prev, next));
return next;
}
/**
* 原子地进行逻辑或操作并返回新值
* 将当前值与给定值进行逻辑或操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算逻辑或结果
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param x 要进行逻辑或操作的值
* @return 操作后的值
*/
public final boolean orAndGet(boolean x) {
boolean prev, next;
do {
prev = get();
next = prev | x;
} while (!compareAndSet(prev, next));
return next;
}
/**
* 原子地进行逻辑异或操作并返回新值
* 将当前值与给定值进行逻辑异或操作
*
* 操作过程：
* 1. 获取当前值
* 2. 计算逻辑异或结果
* 3. 使用CAS操作更新值
* 4. 如果CAS失败，重复步骤1-3
* 5. 返回新值
*
* 时间复杂度：O(1) 平均情况，O(∞) 最坏情况（高竞争）
* 线程安全性：完全原子性
*
* @param x 要进行逻辑异或操作的值
* @return 操作后的值
*/
public final boolean xorAndGet(boolean x) {
boolean prev, next;
do {
prev = get();
next = prev ^ x;
} while (!compareAndSet(prev, next));
return next;
}
/**
* 原子地进行逻辑与操作并返回旧值
*
* @param x 要进行逻辑与操作的值
* @return 操作前的值
*/
public final boolean getAndAnd(boolean x) {
boolean prev, next;
do {
prev = get();
next = prev & x;
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 原子地进行逻辑或操作并返回旧值
*
* @param x 要进行逻辑或操作的值
* @return 操作前的值
*/
public final boolean getAndOr(boolean x) {
boolean prev, next;
do {
prev = get();
next = prev | x;
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 原子地进行逻辑异或操作并返回旧值
*
* @param x 要进行逻辑异或操作的值
* @return 操作前的值
*/
public final boolean getAndXor(boolean x) {
boolean prev, next;
do {
prev = get();
next = prev ^ x;
} while (!compareAndSet(prev, next));
return prev;
}
3. 字符串表示方法（详细注释）
/**
* 返回对象的字符串表示
* 重写Object类的toString方法
*
* @return 当前值的字符串表示
*/
public String toString() {
return Boolean.toString(get());
}
/**
* 计算当前值的哈希码
* 重写Object类的hashCode方法
*
* @return 当前值的哈希码
*/
public int hashCode() {
return Boolean.hashCode(get());
}
/**
* 比较两个AtomicBoolean对象是否相等
* 重写Object类的equals方法
*
* @param obj 要比较的对象
* @return 如果相等返回true，否则返回false
*/
public boolean equals(Object obj) {
if (obj instanceof AtomicBoolean) {
return get() == ((AtomicBoolean)obj).get();
}
return false;
}
4. AtomicBoolean 的特点分析
核心设计理念：
/**
* AtomicBoolean的核心设计思想：
*
* 1. 无锁编程：
* - 使用CAS（Compare-And-Swap）操作实现原子性
* - 避免传统锁的开销和阻塞
* - 提供乐观锁机制
*
* 2. volatile语义：
* - value字段使用volatile修饰（存储为int）
* - 保证内存可见性
* - 确保读操作获取最新值
*
* 3. Unsafe支持：
* - 使用sun.misc.Unsafe类提供底层原子操作
* - 直接操作内存地址，性能优异
* - 绕过JVM的常规访问控制
*
* 4. 偏移量机制：
* - 通过字段偏移量直接访问内存
* - 避免反射开销
* - 提供精确的内存操作
*
* 5. 自旋重试：
* - CAS失败时自动重试
* - 保证操作的最终成功
* - 适用于竞争不激烈的场景
*
* 6. 类型优化：
* - 内部使用int存储boolean值（1表示true，0表示false）
* - 与Unsafe的int操作兼容
* - 避免boolean到int的频繁转换
*
* 7. 逻辑操作支持：
* - 提供与、或、异或等逻辑操作
* - 支持原子的位运算
* - 适用于标志位的复合操作
*
* 适用场景：
* - 状态标志管理
* - 开关控制
* - 线程间简单的布尔值通信
* - 需要原子操作的布尔值计算
* - 高并发环境下的状态同步
*/
性能特征分析：
/**
* AtomicBoolean的性能特征：
*
* 时间复杂度：
* - get(): O(1) - 直接读取volatile字段
* - set(): O(1) - 直接写入volatile字段
* - compareAndSet(): O(1) 平均，O(∞) 最坏
* - 逻辑操作: O(1) 平均，O(∞) 最坏
*
* 空间复杂度：
* - O(1) - 只需要存储一个int值和偏移量
*
* 并发特性：
* - 完全线程安全
* - 无锁设计，避免线程阻塞
* - 乐观锁机制，适用于低竞争场景
* - 高竞争场景下可能出现自旋开销
*
* 与synchronized对比：
* - 无竞争：AtomicBoolean > synchronized
* - 低竞争：AtomicBoolean > synchronized
* - 高竞争：AtomicBoolean可能 < synchronized
* - 内存开销：AtomicBoolean < synchronized
*
* 与AtomicInteger/AtomicLong对比：
* - 功能相似：都提供原子操作
* - 内存使用：AtomicBoolean ≈ AtomicInteger < AtomicLong
* - 性能：AtomicBoolean ≥ AtomicInteger ≥ AtomicLong
* - 适用场景：AtomicBoolean专门用于布尔值操作
*
* CAS操作特点：
* - 乐观锁：假设没有冲突，冲突时重试
* - 非阻塞：不会阻塞其他线程
* - ABA问题：对于boolean类型不会出现
* - 自旋开销：高竞争时CPU使用率可能较高
*
* 内存使用：
* - 每个实例固定开销很小
* - volatile字段保证可见性
* - 及时GC，避免内存泄漏
*
* 适用性：
* - 布尔值原子操作：性能优异
* - 状态标志管理：性能优异
* - 简单同步逻辑：比锁更灵活
* - 复杂同步逻辑：可能不如锁机制
*/
5. 使用示例和最佳实践
/**
* 使用示例：
*
* // 基本使用
* AtomicBoolean flag = new AtomicBoolean(false);
*
* // 获取和设置值
* boolean currentValue = flag.get();
* flag.set(true);
*
* // 比较并设置
* boolean success = flag.compareAndSet(false, true);
* if (success) {
* System.out.println("Flag updated successfully");
* } else {
* System.out.println("Flag update failed");
* }
*
* // 原子地设置新值并返回旧值
* boolean oldValue = flag.getAndSet(true);
*
* // 逻辑操作
* AtomicBoolean status = new AtomicBoolean(true);
*
* // 逻辑与操作
* boolean andResult = status.andAndGet(false); // 结果为false
*
* // 逻辑或操作
* boolean orResult = status.orAndGet(true); // 结果为true
*
* // 逻辑异或操作
* boolean xorResult = status.xorAndGet(true); // 结果为false
*
* // 线程间状态同步示例
* class ThreadSafeFlag {
* private final AtomicBoolean running = new AtomicBoolean(false);
*
* public boolean start() {
* return running.compareAndSet(false, true);
* }
*
* public boolean stop() {
* return running.compareAndSet(true, false);
* }
*
* public boolean isRunning() {
* return running.get();
* }
*
* public void forceStop() {
* running.set(false);
* }
* }
*
* // 生产者-消费者状态控制示例
* class ProducerConsumerControl {
* private final AtomicBoolean producing = new AtomicBoolean(false);
* private final AtomicBoolean consuming = new AtomicBoolean(false);
*
* public boolean startProducing() {
* // 确保没有在消费时开始生产
* if (!consuming.get()) {
* return producing.compareAndSet(false, true);
* }
* return false;
* }
*
* public boolean startConsuming() {
* // 确保没有在生产时开始消费
* if (!producing.get()) {
* return consuming.compareAndSet(false, true);
* }
* return false;
* }
*
* public void stopProducing() {
* producing.set(false);
* }
*
* public void stopConsuming() {
* consuming.set(false);
* }
*
* public boolean isProducing() {
* return producing.get();
* }
*
* public boolean isConsuming() {
* return consuming.get();
* }
* }
*
* // 多线程协作示例
* class MultiThreadCoordinator {
* private final AtomicBoolean initialized = new AtomicBoolean(false);
* private final AtomicBoolean shutdown = new AtomicBoolean(false);
*
* public void initialize() {
* if (initialized.compareAndSet(false, true)) {
* // 执行初始化逻辑
* System.out.println("Initializing...");
* }
* }
*
* public void shutdown() {
* if (shutdown.compareAndSet(false, true)) {
* // 执行关闭逻辑
* System.out.println("Shutting down...");
* }
* }
*
* public boolean isInitialized() {
* return initialized.get();
* }
*
* public boolean isShutdown() {
* return shutdown.get();
* }
*
* public boolean isActive() {
* return initialized.get() && !shutdown.get();
* }
* }
*
* 最佳实践：
*
* 1. 正确使用compareAndSet：
* AtomicBoolean flag = new AtomicBoolean(false);
*
* // 正确使用：检查返回值
* public boolean trySetFlag(boolean newValue) {
* boolean expected = !newValue;
* return flag.compareAndSet(expected, newValue);
* }
*
* // 错误使用：忽略返回值
* // flag.compareAndSet(false, true); // 没有检查返回值
*
* 2. 合理使用逻辑操作：
* AtomicBoolean status = new AtomicBoolean(true);
*
* // 原子地设置标志位
* public void setFlagAtomic() {
* status.set(true);
* }
*
* // 原子地翻转标志位
* public void toggleFlag() {
* boolean current = status.get();
* status.compareAndSet(current, !current);
* }
*
* // 原子地进行逻辑操作
* public boolean andFlag(boolean value) {
* return status.andAndGet(value);
* }
*
* 3. 避免竞态条件：
* AtomicBoolean flag = new AtomicBoolean(false);
*
* // 错误的做法：非原子操作
* // if (!flag.get()) {
* // flag.set(true); // 可能出现竞态条件
* // }
*
* // 正确的做法：使用CAS
* public boolean tryAcquire() {
* return flag.compareAndSet(false, true);
* }
*
* 4. 处理复杂的状态转换：
* AtomicBoolean state = new AtomicBoolean(false);
*
* // 复杂的状态转换逻辑
* public boolean transitionState(boolean expected, boolean target) {
* return state.compareAndSet(expected, target);
* }
*
* // 条件状态设置
* public boolean conditionalSet(boolean condition, boolean newValue) {
* if (condition) {
* return state.compareAndSet(!newValue, newValue);
* }
* return false;
* }
*
* 5. 使用懒设置优化性能：
* AtomicBoolean flag = new AtomicBoolean(false);
*
* // 当不需要立即可见性时使用lazySet
* public void lazyUpdate(boolean newValue) {
* flag.lazySet(newValue); // 可能有更好的性能
* }
*
* // 当需要立即可见性时使用set
* public void immediateUpdate(boolean newValue) {
* flag.set(newValue); // 确保立即可见
* }
*
* 6. 监控和调试：
* AtomicBoolean flag = new AtomicBoolean(false);
*
* // 定期检查状态
* public void logStatus() {
* System.out.println("Current flag value: " + flag.get());
* }
*
* // 性能监控
* public void monitorPerformance() {
* long startTime = System.nanoTime();
* // 执行一些操作
* for (int i = 0; i < 1000000; i++) {
* flag.compareAndSet(false, true);
* flag.compareAndSet(true, false);
* }
* long endTime = System.nanoTime();
* System.out.println("Time taken: " + (endTime - startTime) + " ns");
* }
*
* 7. 异常处理：
* AtomicBoolean flag = new AtomicBoolean(false);
*
* public void safeUpdate(boolean newValue) {
* try {
* flag.set(newValue);
* } catch (Exception e) {
* System.err.println("Update failed: " + e.getMessage());
* // 记录日志或采取其他措施
* }
* }
*
* 8. 批量操作优化：
* // 当需要多个标志位时，考虑使用位操作
* class MultiFlag {
* private final AtomicInteger flags = new AtomicInteger(0);
*
* public void setFlag(int position, boolean value) {
* int mask = 1 << position;
* if (value) {
* flags.getAndOr(mask);
* } else {
* flags.getAndAnd(~mask);
* }
* }
*
* public boolean getFlag(int position) {
* int mask = 1 << position;
* return (flags.get() & mask) != 0;
* }
* }
*
* 9. 状态机实现：
* class SimpleStateMachine {
* private final AtomicBoolean state = new AtomicBoolean(false);
* public static final boolean STATE_A = false;
* public static final boolean STATE_B = true;
*
* public boolean transitionToA() {
* return state.compareAndSet(STATE_B, STATE_A);
* }
*
* public boolean transitionToB() {
* return state.compareAndSet(STATE_A, STATE_B);
* }
*
* public boolean isInStateA() {
* return state.get() == STATE_A;
* }
*
* public boolean isInStateB() {
* return state.get() == STATE_B;
* }
* }
*
* 10. 性能调优：
* // 在高并发场景下监控性能
* AtomicBoolean flag = new AtomicBoolean(false);
*
* // 使用局部变量减少volatile访问
* public void optimizedCheck() {
* boolean localFlag = flag.get();
* if (localFlag) {
* // 执行相关逻辑
* }
* }
*
* // 避免不必要的原子操作
* public void conditionalOperation() {
* if (flag.get()) { // 先检查
* // 再执行原子操作
* flag.compareAndSet(true, false);
* }
* }
*/
6. 与其他原子类的比较
/**
* AtomicBoolean vs AtomicInteger vs AtomicLong vs AtomicReference:
*
* AtomicBoolean:
* - 用于boolean类型的操作
* - 提供get/set/compareAndSet等方法
* - 内部使用int存储（1表示true，0表示false）
* - 适用于状态标志
* - 内存效率高
*
* AtomicInteger:
* - 用于int类型的操作
* - 提供丰富的数学运算方法
* - 32位整数操作
* - 最常用的原子类
*
* AtomicLong:
* - 用于long类型的操作
* - 提供与AtomicInteger类似的方法
* - 64位整数操作
* - 适用于需要更大数值范围的场景
*
* AtomicReference:
* - 用于对象引用的操作
* - 支持CAS操作对象引用
* - 适用于复杂对象的原子操作
* - 可以配合AtomicStampedReference解决ABA问题
*
* 性能对比：
* - 基本操作：AtomicBoolean ≈ AtomicInteger > AtomicLong > AtomicReference
* - 内存使用：AtomicBoolean ≤ AtomicInteger < AtomicLong < AtomicReference
* - 功能丰富度：AtomicReference > AtomicLong ≈ AtomicInteger > AtomicBoolean
*
* 选择建议：
* - 状态标志：AtomicBoolean
* - 简单计数：AtomicInteger
* - 大数值计数：AtomicLong
* - 对象引用：AtomicReference
* - 需要版本控制：AtomicStampedReference
* - 需要标记引用：AtomicMarkableReference
*
* 使用场景：
* - AtomicBoolean：开关、标志位、简单的状态管理
* - AtomicInteger：计数器、序列号、简单的数值操作
* - AtomicLong：时间戳、大计数器、需要64位精度的场景
* - AtomicReference：复杂对象的原子操作、缓存引用
*/
7. 总结
AtomicBoolean 的核心特性：
-
无锁原子操作：
- 使用CAS实现原子性
- 避免传统锁的开销
- 提供乐观锁机制
-
内存可见性：
- value字段使用volatile修饰（存储为int）
- 保证多线程间的内存可见性
- 确保读操作获取最新值
-
丰富的原子操作：
- 基本的get/set操作
- 比较并设置操作
- 逻辑运算操作（与、或、异或）
-
类型优化：
- 内部使用int存储boolean值
- 与Unsafe的int操作兼容
- 避免频繁的类型转换
-
高性能设计：
- 基于Unsafe的底层操作
- 字段偏移量直接访问
- 自旋重试机制
-
线程安全：
- 所有操作都是线程安全的
- 适用于高并发环境
- 无死锁风险
适用场景：
- 状态标志管理
- 开关控制
- 线程间简单的布尔值通信
- 需要原子操作的布尔值计算
- 高并发环境下的状态同步
注意事项：
- CAS操作虽然对于boolean类型不会出现ABA问题，但仍需正确处理返回值
- 高竞争场景下可能有自旋开销
- 不支持复合原子操作（需要多个步骤的原子操作）
- 需要正确处理CAS的返回值
- 注意选择合适的更新方法
性能优化建议：
- 根据用途选择合适的原子类
- 合理使用compareAndSet避免不必要的操作
- 在不需要立即可见性时使用lazySet
- 监控原子操作的性能表现
- 避免不必要的原子操作
- 正确处理CAS的返回值
- 考虑使用局部变量减少volatile访问
- 在复杂状态管理时考虑使用AtomicInteger进行位操作
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
