Java面试题：如何使用原子类（如AtomicInteger）来实现线程安全的计数

在 Java 中，java.util.concurrent.atomic 包提供了一组原子类，它们用于在多线程环境中执行原子操作。AtomicInteger 是这个包中最基本的原子类之一，它提供了一种线程安全的方式来进行整数的原子操作。以下是如何使用 AtomicInteger 来实现线程安全的计数：

1. 基本使用：
   AtomicInteger 类提供了基本的原子操作，如 incrementAndGet()、decrementAndGet()、getAndIncrement() 等，这些方法都是线程安全的。

   AtomicInteger count = new AtomicInteger(0); // 初始化计数器为0
   
   // 线程安全的自增操作
   int newValue = count.incrementAndGet();
   
   // 线程安全的自减操作
   int currentValue = count.decrementAndGet();
   
   // 获取当前值
   int value = count.get();
   

2. 在多线程中使用：
   当多个线程需要对同一个计数器进行操作时，AtomicInteger 可以确保这些操作是原子的，不会出现线程间的数据竞争。

   public class AtomicIntegerExample {
       static AtomicInteger counter = new AtomicInteger(0);
   
       public static void main(String[] args) {
           int numberOfThreads = 10;
           Thread[] threads = new Thread[numberOfThreads];
   
           for (int i = 0; i < numberOfThreads; i++) {
               threads[i] = new Thread(() -> {
                   for (int j = 0; j < 100; j++) {
                       counter.incrementAndGet();
                   }
               });
               threads[i].start();
           }
   
           for (int i = 0; i < numberOfThreads; i++) {
               try {
                   threads[i].join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
   
           System.out.println("Final count: " + counter.get());
       }
   }
   

   在这个例子中，我们创建了 10 个线程，每个线程执行 100 次自增操作。由于使用了 AtomicInteger，即使在多线程环境下，最终的计数结果也是准确的。

3. 复合操作：
   AtomicInteger 还支持复合操作，例如 addAndGet(int) 和 getAndAdd(int)，这些方法允许你执行更复杂的原子操作。

   // 将当前值与给定的值相加，然后返回新的值
   int newTotal = count.addAndGet(10);
   
   // 获取当前值，并将给定的值与当前值相加
   int currentTotal = count.getAndAdd(10);
   

4. 使用 compareAndSet 方法：
   AtomicInteger 提供了 compareAndSet(expectedValue, newValue) 方法，它允许你进行条件原子操作。如果当前值等于 expectedValue，则将值设置为 newValue。

   boolean swapped = count.compareAndSet(expectedValue, newValue);
   if (swapped) {
       // 如果返回 true，说明值已经被成功更新
   }
   

使用 AtomicInteger 可以避免使用 synchronized 关键字或显式锁（如 ReentrantLock），从而减少锁竞争，提高程序的并发性能。同时，它也简化了线程安全的编程模型。