Java AtomicInteger原理用法源码详解

文章目录

  • Java AtomicInteger原理用法源码详解
    • 基本原理
    • 注意事项
    • 基本方法
    • 场景示例
    • 中文源码
    • 官方链接

基本原理

Java 中的 AtomicInteger 是一个原子类,用于实现对整数类型的原子操作。它提供了一系列方法,如 get()set()incrementAndGet()compareAndSet() 等,可以在多线程环境下安全地进行原子操作。通过使用 AtomicInteger,可以避免使用显式的锁来保护共享整数变量,从而提高并发性能。它适用于许多并发场景,如计数器、标记位等。

AtomicInteger 的原理基于 CAS(Compare-And-Swap)操作。它内部使用了 Unsafe 类或者其他底层的原子操作机制来实现线程安全的操作。通过 CAS 操作,AtomicInteger 可以保证在多线程环境下对整数值的修改是原子性的,避免了竞态条件和数据不一致等问题。

AtomicInteger 的主要特点和原理如下:

  1. 内部使用 volatile 修饰的 int 变量:AtomicInteger 内部有一个被 volatile 修饰的 int 变量,用于存储整数值。volatile 关键字确保了变量的可见性,使得对该变量的读写操作具有原子性。
  2. 使用 CAS 操作进行原子更新:AtomicInteger 中的原子操作方法都是基于 CAS 操作实现的。CAS 操作包括比较内存中的值与预期值是否相等,如果相等则更新为新值,否则操作失败。CAS 操作利用底层硬件提供的原子指令,确保操作的原子性。
  3. 循环重试:由于 CAS 操作可能在多线程环境下失败,因此 AtomicInteger 在实现中使用了循环重试的机制。如果 CAS 操作失败,它会不断尝试进行 CAS 操作,直到成功为止。

注意事项

  • AtomicInteger 并不能完全替代 Integer 类,因为它并没有提供自动装箱和拆箱的功能。

  • 虽然 AtomicInteger 提供了原子操作,但仍然需要根据具体情况考虑原子类的使用范围和正确性。有时候,可能需要额外的同步手段来保证一些复合操作的原子性。

    假设需要对一个计数器进行原子递增和条件检查,以决定是否执行某个操作。以下是一个示例代码:

if (counter.incrementAndGet() >= threshold) {
// 执行操作
}

尽管递增操作和条件检查各自都是原子的,但由于两个操作之间存在竞态条件,可能会导致结果不一致。因为在判断条件后,其他线程可能已经对计数器进行了修改。在这种情况下,可以使用额外的同步手段,如锁(`synchronized`)或者显示的使用 `Lock` 接口,来保证多个操作的原子性,可以确保递增操作、条件检查和操作的执行之间是原子的,避免了竞态条件。```javasynchronized (lock) {if (counter.incrementAndGet() >= threshold) {// 执行操作}}

基本方法

以下是对 AtomicInteger 类中提供的方法进行总结:

  • AtomicInteger(int initialValue):使用给定的初始值创建一个新的 AtomicInteger 对象。

  • AtomicInteger():创建一个新的 AtomicInteger 对象,并将初始值设为 0。

  • int get():获取当前存储的整数值。

  • void set(int newValue):设置整数值为指定的新值。

  • void lazySet(int newValue):最终将整数值设置为指定的新值。不保证立即生效,可能会延迟。

  • int getAndSet(int newValue):将整数值设置为指定的新值,并返回先前的值。

  • boolean compareAndSet(int expect, int update):如果当前值等于预期值,则原子地将整数值设置为指定的新值,并返回操作是否成功。

  • boolean weakCompareAndSet(int expect, int update):与 compareAndSet() 方法类似,但不提供强有力的保证和排序保证。

  • int getAndIncrement():先返回当前值,然后将整数值增加 1。

  • int getAndDecrement():先返回当前值,然后将整数值减少 1。

  • int getAndAdd(int delta):先返回当前值,然后将整数值增加指定的增量。

  • int incrementAndGet():将整数值增加 1,然后返回更新后的值。

  • int decrementAndGet():将整数值减少 1,然后返回更新后的值。

  • int addAndGet(int delta):将整数值增加指定的增量,然后返回更新后的值。

  • int getAndUpdate(IntUnaryOperator updateFunction):先获取当前值,然后将整数值更新为通过应用给定函数得到的新值,返回先前的值。

  • int updateAndGet(IntUnaryOperator updateFunction):先获取当前值,然后将整数值更新为通过应用给定函数得到的新值,返回更新后的值。

  • int getAndAccumulate(int x, IntBinaryOperator accumulatorFunction):先获取当前值,然后将整数值与给定值通过应用给定函数进行累积计算,返回先前的值。

  • int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction):先获取当前值,然后将整数值与给定值通过应用给定函数进行累积计算,返回更新后的值。

  • String toString():以字符串形式返回当前存储的整数值。

  • int intValue():将当前存储的整数值转换为 int 类型并返回。

  • long longValue():将当前存储的整数值转换为 long 类型并返回。

  • float floatValue():将当前存储的整数值转换为 float 类型并返回。

  • double doubleValue():将当前存储的整数值转换为 double 类型并返回。

这些方法允许原子地对整数值进行各种操作,确保在多线程环境下的线程安全性。

场景示例

以下是几个适用场景和示例:

  1. 计数器(Counter)AtomicInteger 可以用作计数器,在多线程环境下实现原子的自增、自减操作。例如,统计网站访问次数或任务完成数量等。
public class Counter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();}public void decrement() {count.decrementAndGet();}public int getCount() {return count.get();}}
  1. 并发任务处理:在并发任务处理中,可以使用 AtomicInteger 来控制任务的执行顺序或限制同时执行的任务数量。
import java.util.concurrent.atomic.AtomicInteger;public class TaskProcessor {private static final int MAX_CONCURRENT_TASKS = 10;private AtomicInteger activeTasks = new AtomicInteger(0);public void processTask(Runnable task) {// 检查是否达到最大并发任务数while (activeTasks.get() >= MAX_CONCURRENT_TASKS) {// 等待其他任务完成后再继续执行Thread.yield();}try {activeTasks.incrementAndGet(); // 增加活动任务数task.run(); // 执行任务} finally {activeTasks.decrementAndGet(); // 减少活动任务数}}}
  1. 线程安全的共享变量:当多个线程需要共享某个变量时,可以使用 AtomicInteger 来保证线程安全。例如,在多个线程中对共享计数器进行递增操作。
import java.util.concurrent.atomic.AtomicInteger;public class SharedVariableExample {private static AtomicInteger counter = new AtomicInteger(0);public static void main(String[] args) throws InterruptedException {Runnable task = () -> {for (int i = 0; i < 1000; i++) {counter.incrementAndGet(); // 原子递增操作}};Thread thread1 = new Thread(task);Thread thread2 = new Thread(task);thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("Counter value: " + counter.get());}}

在上述示例中,两个线程并发地对 counter 进行递增操作,通过 AtomicInteger 来保证递增操作的原子性,并最终输出正确的计数器值。

总之,AtomicInteger 适用于多线程环境下对整数进行原子操作的场景,如计数器、并发任务处理和线程安全的共享变量等。它提供了一种高效且线程安全的方式来处理整数操作。

中文源码

/** * 一个可以原子更新的 {@code int} 值。请参阅 {@link java.util.concurrent.atomic} 包规范,了解原子变量的属性描述。 * {@code AtomicInteger} 在诸如原子递增计数器等应用中使用,不能用作 {@link java.lang.Integer} 的替代品。 * 但是,该类扩展了 {@code Number} 类,以便允许工具和实用程序对基于数字的类进行统一访问。 * * @since 1.5 * @author Doug Lea */public class AtomicInteger extends Number implements java.io.Serializable {private static final long serialVersionUID = 6214790243416807050L;// 设置使用 Unsafe.compareAndSwapInt 进行更新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; // 使用 volatile 修饰,保证可见性/** * 使用给定的初始值创建一个新的 {@code AtomicInteger}。 * * @param initialValue 初始值 */public AtomicInteger(int initialValue) {value = initialValue; // 初始化整数值}/** * 创建一个初始值为 {@code 0} 的新 {@code AtomicInteger}。 */public AtomicInteger() {}/** * 获取当前值。 * * @return 当前值 */public final int get() {return value; // 获取当前存储的整数值}/** * 设置为给定值。 * * @param newValue 新值 */public final void set(int newValue) {value = newValue; // 设置整数值为指定的新值}/** * 最终设置为给定值。 * * @param newValue 新值 * @since 1.6 */public final void lazySet(int newValue) {unsafe.putOrderedInt(this, valueOffset, newValue); // 最终设置整数值为指定的新值,可能会延迟生效}/** * 原子地设置为给定值,并返回旧值。 * * @param newValue 新值 * @return 先前的值 */public final int getAndSet(int newValue) {return unsafe.getAndSetInt(this, valueOffset, newValue); // 原子地设置整数值为指定的新值,并返回先前的值}/** * 如果当前值 {@code ==} 预期值,则原子地将值设置为给定更新值。 * * @param expect 预期值 * @param update 新值 * @return {@code true} 表示成功。返回 {@code false} 表示实际值不等于预期值。 */public final boolean compareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update); // 如果当前值等于预期值,则原子地将整数值设置为指定的新值,并返回操作是否成功}/** * 如果当前值 {@code ==} 预期值,则原子地将值设置为给定更新值。 * * 

可能会出现虚假失败,不提供排序保证, * 因此很少作为 {@code compareAndSet} 的替代方法。 * * @param expect 预期值 * @param update 新值 * @return {@code true} 表示成功 */public final boolean weakCompareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update); // 弱 CAS 操作,不提供强有力的保证和排序保证}/** * 原子地将当前值加 1。 * * @return 先前的值 */public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1); // 先返回当前值,然后将整数值增加 1}/** * 原子地将当前值减 1。 * * @return 先前的值 */public final int getAndDecrement() {return unsafe.getAndAddInt(this, valueOffset, -1); // 先返回当前值,然后将整数值减少 1}/** * 原子地将给定值加到当前值。 * * @param delta 要添加的值 * @return 先前的值 */public final int getAndAdd(int delta) {return unsafe.getAndAddInt(this, valueOffset, delta); // 先返回当前值,然后将整数值增加指定的增量}/** * 原子地将当前值加 1。 * * @return 更新后的值 */public final int incrementAndGet() {return unsafe.getAndAddInt(this, valueOffset, 1) + 1; // 将整数值增加 1,然后返回更新后的值}/** * 原子地将当前值减 1。 * * @return 更新后的值 */public final int decrementAndGet() {return unsafe.getAndAddInt(this, valueOffset, -1) - 1; // 将整数值减少 1,然后返回更新后的值}/** * 原子地将给定值添加到当前值。 * * @param delta 要添加的值 * @return 更新后的值 */public final int addAndGet(int delta) {return unsafe.getAndAddInt(this, valueOffset, delta) + delta; // 将整数值增加指定的增量,然后返回更新后的值}/** * 使用给定函数原子地更新当前值,并返回先前的值。由于可能在线程之间产生争用时重新应用尝试更新, * 因此该函数应是无副作用的。 * * @param updateFunction 无副作用的函数 * @return 先前的值 * @since 1.8 */public final int getAndUpdate(IntUnaryOperator updateFunction) {int prev, next;do {prev = get();next = updateFunction.applyAsInt(prev);} while (!compareAndSet(prev, next));return prev;}/** * 使用给定函数原子地更新当前值,并返回更新后的值。由于可能在线程之间产生争用时重新应用尝试更新, * 因此该函数应是无副作用的。 * * @param updateFunction 无副作用的函数 * @return 更新后的值 * @since 1.8 */public final int updateAndGet(IntUnaryOperator updateFunction) {int prev, next;do {prev = get();next = updateFunction.applyAsInt(prev);} while (!compareAndSet(prev, next));return next;}/** * 使用给定函数将当前值和给定值原子地更新,并返回先前的值。由于可能在线程之间产生争用时重新应用尝试更新, * 因此该函数应是无副作用的。该函数将当前值作为第一个参数,给定更新作为第二个参数应用。 * * @param x 更新值 * @param accumulatorFunction 两个参数的无副作用函数 * @return 先前的值 * @since 1.8 */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;}/** * 使用给定函数将当前值和给定值原子地更新,并返回更新后的值。由于可能在线程之间产生争用时重新应用尝试更新, * 因此该函数应是无副作用的。该函数将当前值作为第一个参数,给定更新作为第二个参数应用。 * * @param x 更新值 * @param accumulatorFunction 两个参数的无副作用函数 * @return 更新后的值 * @since 1.8 */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;}/** * 返回当前值的字符串表示形式。 * * @return 当前值的字符串表示形式 */public String toString() {return Integer.toString(get());}/** * 将此 {@code AtomicInteger} 的值作为 {@code int} 返回。 */public int intValue() {return get();}/** * 将此 {@code AtomicInteger} 的值作为 {@code long} 返回,进行扩展原始转换。 * @jls 5.1.2 扩展原始类型转换 */public long longValue() {return (long)get();}/** * 将此 {@code AtomicInteger} 的值作为 {@code float} 返回,进行扩展原始转换。 * @jls 5.1.2 扩展原始类型转换 */public float floatValue() {return (float)get();}/** * 将此 {@code AtomicInteger} 的值作为 {@code double} 返回,进行扩展原始转换。 * @jls 5.1.2 扩展原始类型转换 */public double doubleValue() {return (double)get();}}

官方链接