如何在Java中实现线程安全的计数器累加-java教程-PHP中文网

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

P粉602998670

发布： 2025-10-29 10:12:02

原创

159人浏览过

答案：Java中实现线程安全计数器有四种方式：1. synchronized关键字通过加锁保证互斥，简单但高并发性能差；2. AtomicInteger利用CAS实现无锁原子操作，适合一般高并发场景；3. ReentrantLock提供更灵活的锁控制，适用于需显式锁管理的场景；4. LongAdder采用分段累加策略，在极端高并发写入时性能最优，但读取需汇总开销。应根据并发程度和读写比例选择合适方案。

如何在java中实现线程安全的计数器累加

在多线程环境下，实现一个线程安全的计数器是常见的需求。如果多个线程同时对共享变量进行累加操作，可能会因为竞态条件导致结果不准确。Java提供了多种方式来保证计数器的线程安全。以下是几种常用的实现方法。

1. 使用 synchronized 关键字

最直接的方式是使用 synchronized 关键字来保证方法或代码块的同步执行，确保同一时间只有一个线程能访问共享资源。

示例代码：

public class SynchronizedCounter {
    private int count = 0;

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

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

登录后复制

这种方式简单可靠，但可能在高并发场景下性能较低，因为每次只能有一个线程进入同步方法。

2. 使用 AtomicInteger

Java 提供了 java.util.concurrent.atomic 包中的 AtomicInteger 类，它基于 CAS（Compare-And-Swap）机制实现无锁的线程安全操作，性能优于 synchronized。

立即学习“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 适合高并发场景，避免了锁的开销，是推荐的实现方式之一。

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

查看详情

3. 使用 ReentrantLock 显式锁

通过 ReentrantLock 可以更灵活地控制锁的行为，比如尝试获取锁、设置超时等。

示例代码：

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

登录后复制

相比 synchronized，ReentrantLock 提供了更多控制选项，但在大多数情况下，synchronized 更简洁易用。

4. 使用 LongAdder（高并发优化）

在极高并发的累加场景中，LongAdder 比 AtomicInteger 性能更好。它通过分段累加再汇总的方式减少竞争。

示例代码：

import java.util.concurrent.atomic.LongAdder;

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

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

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

登录后复制

当读操作远少于写操作时，LongAdder 是最佳选择；若频繁读取值，则 sum() 的开销需考虑。

基本上就这些。根据并发程度和性能要求选择合适的方式：低并发用 synchronized，一般高并发选 AtomicInteger，极端高并发考虑 LongAdder。不复杂但容易忽略细节，关键是理解每种机制的适用场景。

以上就是如何在Java中实现线程安全的计数器累加的详细内容，更多请关注php中文网其它相关文章！