在多线程编程中，共享资源的访问控制是一个核心问题。计数器作为最常见的一种共享状态，经常被多个线程同时读写。如果处理不当，就会出现数据不一致、结果错误等问题。因此，如何在Java中实现一个真正线程安全的计数器，是每个开发者必须掌握的基础技能。

我们先来看一个简单的非线程安全示例：

java
public class UnsafeCounter {
private int count = 0;

public void increment() {
    count++; // 非原子操作
}

public int getCount() {
    return count;
}

}

上述代码看似正常，但在多线程环境下，count++ 实际上包含了三个步骤：读取当前值、加1、写回内存。当多个线程同时执行时，这些步骤可能交错进行，导致某些递增操作丢失，最终结果小于预期。

为了解决这个问题，Java提供了多种实现线程安全计数器的方法，下面逐一分析其原理和适用场景。

使用 synchronized 关键字

最直观的方式是使用 synchronized 来保证方法的互斥执行：

java
public class SynchronizedCounter {
private int count = 0;

public synchronized void increment() {
    count++;
}

public synchronized int getCount() {
    return count;
}

}

synchronized 通过对象锁机制确保同一时刻只有一个线程能进入方法体。这种方式简单可靠，但性能开销较大，特别是在高并发场景下，频繁的线程阻塞和上下文切换会影响整体效率。

使用 AtomicInteger 类

Java 并发包（java.util.concurrent.atomic）提供了 AtomicInteger，它基于底层的 CAS（Compare-And-Swap）操作实现无锁并发控制：

java
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);

public void increment() {
    count.incrementAndGet(); // 原子性递增
}

public int getCount() {
    return count.get();
}

}

AtomicInteger 的优势在于它不需要加锁，利用 CPU 提供的原子指令完成操作，避免了传统锁带来的性能瓶颈。在大多数高并发场景下，它是实现线程安全计数器的首选方案。

CAS 操作的核心思想是：在修改变量前先检查其当前值是否与预期值一致，若一致则更新，否则重试。这种“乐观锁”机制在冲突较少的情况下表现优异。

volatile 的局限性

有些开发者可能会尝试使用 volatile 关键字来修饰计数器变量：

java
public class VolatileCounter {
private volatile int count = 0;

public void increment() {
    count++; // 依然不是原子操作
}

}

然而，volatile 只能保证变量的可见性和禁止指令重排序，并不能保证复合操作的原子性。因此，count++ 在 volatile 修饰下仍然是线程不安全的。这一点需要特别注意，避免误用。

实际应用场景对比

在实际开发中，选择哪种方式取决于具体需求：

• 如果计数操作频率不高，且对性能要求不苛刻，使用 synchronized 是稳妥的选择。
• 对于高频读写、追求高性能的场景，如统计接口调用量、限流控制等，应优先考虑 AtomicInteger。
• 若需要更复杂的原子操作（如先比较再设置），可以结合 AtomicReference 或其他原子类扩展功能。

此外，LongAdder 是 JDK 8 引入的一个更高性能的计数器实现，特别适合高并发下的累加场景。它通过分段累加减少竞争，最终汇总结果，在极端并发条件下比 AtomicInteger 表现更好。

java
import java.util.concurrent.atomic.LongAdder;

public class HighPerformanceCounter {
private LongAdder count = new LongAdder();

public void increment() {
    count.increment();
}

public long getCount() {
    return count.sum();
}

}

综上所述，实现线程安全的计数器并非只有一种方式。理解每种机制背后的原理，根据实际业务场景做出合理选择，才是写出高质量并发代码的关键。从 synchronized 到 AtomicInteger，再到 LongAdder，Java 为开发者提供了丰富的工具链，帮助我们在复杂多变的并发世界中保持数据的一致性与程序的稳定性。