如何在Java中实现多线程安全的计数器

P粉602998670 2025-10-15 00:00:00 次阅读

答案：Java中实现线程安全计数器主要有三种方法：1. 使用synchronized关键字确保方法同步，适合低并发；2. 使用AtomicInteger类的CAS操作，无锁且高性能，推荐用于高并发；3. 使用ReentrantLock显式锁，提供更灵活的锁控制，适用于复杂场景。选择依据性能需求和使用情境，其中AtomicInteger因高效简洁最为常用。

在Java中实现多线程安全的计数器，关键在于确保多个线程对计数器的读取、修改和写入操作是原子且可见的。下面介绍几种常用且有效的方法。

使用 synchronized 关键字

通过 synchronized 保证方法或代码块在同一时刻只能被一个线程执行，从而避免竞态条件。

将计数器的递增操作放在 synchronized 方法中，确保线程安全。
适用于简单场景，但可能影响性能，因为存在锁竞争。

示例代码：

public class SynchronizedCounter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

使用 AtomicInteger 类

java.util.concurrent.atomic 包中的 AtomicInteger 提供了基于 CAS（Compare-and-Swap）的无锁线程安全操作，性能通常优于 synchronized。

incrementAndGet() 方法是原子操作，适合高并发环境。
无需显式加锁，减少线程阻塞。

示例代码：

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();
    }
}

使用 ReentrantLock 显式锁

ReentrantLock 提供了比 synchronized 更灵活的锁机制，比如可中断、超时尝试获取锁等。

需要手动加锁和释放锁，注意必须在 finally 块中释放，防止死锁。
适合复杂同步逻辑的场景。

示例代码：

import java.util.concurrent.locks.ReentrantLock;

public class LockedCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}