Java核心语法-AtomicInteger简介

一、AtomicInteger简介

AtomicInteger 是 Java 中的一个原子整数类型，位于 java.util.concurrent.atomic 包中。它主要用于多线程环境下，提供线程安全的整数操作，无需使用 synchronized 锁。
核心特点：

• 原子性：所有操作都是原子的，不会被线程调度机制打断。
• 无锁：基于 CAS（Compare-And-Swap）实现，性能优于 synchronized。
• 可见性：保证变量在多线程间的可见性。

常用方法：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    
    public static void main(String[] args) {
        // 创建 AtomicInteger
        AtomicInteger atomicInt = new AtomicInteger(0);
        
        // 1. 获取当前值
        int value = atomicInt.get();
        
        // 2. 设置新值
        atomicInt.set(10);
        
        // 3. 自增（原子操作）
        atomicInt.incrementAndGet();      // 先自增，后返回 (11)
        int val1 = atomicInt.getAndIncrement();  // 先返回，后自增 (11)
        
        // 4. 自减（原子操作）
        atomicInt.decrementAndGet();      // 先自减，后返回
        int val2 = atomicInt.getAndDecrement();  // 先返回，后自减
        
        // 5. 累加
        atomicInt.addAndGet(5);           // 先累加，后返回
        int val3 = atomicInt.getAndAdd(5); // 先返回，后累加
        
        // 6. CAS 操作：比较并交换
        boolean success = atomicInt.compareAndSet(10, 20);  // 如果当前值是 10，则改为 20
        
        // 7. 获取并更新
        atomicInt.getAndUpdate(i -> i * 2);  // 返回旧值，然后更新
        atomicInt.updateAndGet(i -> i * 2);  // 更新后，返回新值
    }
}

二、 应用场景

典型使用场景
场景 1：线程安全的计数器：

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();  // 线程安全的自增
    }
    
    public int getCount() {
        return count.get();
    }
}

场景 2：生成唯一序列号：

public class IdGenerator {
    private static AtomicInteger idCounter = new AtomicInteger(1);
    
    public static int generateId() {
        return idCounter.getAndIncrement();
    }
}

场景 3：控制并发访问次数：

public class AccessController {
    private AtomicInteger accessCount = new AtomicInteger(0);
    private final int maxAccess = 100;
    
    public boolean tryAccess() {
        int current = accessCount.getAndIncrement();
        if (current < maxAccess) {
            return true;  // 允许访问
        } else {
            accessCount.decrementAndGet();  // 恢复计数
            return false;  // 拒绝访问
        }
    }
}

在 Spring Cloud 微服务项目中使用，如果需要在线程安全的场景下使用计数器，比如在：
统计接口调用次数。
生成订单编号。
控制并发请求数。

可以直接引入使用：

import java.util.concurrent.atomic.AtomicInteger;

@Service
public class YourService {
    private AtomicInteger counter = new AtomicInteger(0);
    
    public void someMethod() {
        // 线程安全的计数
        counter.incrementAndGet();
    }
}

总结：AtomicInteger 是多线程编程中的利器，适合需要频繁更新且要求线程安全的数值操作场景，性能比使用 synchronized 锁更好。