如何用Atomic实现计数器

使用 Atomic 实现计数器是一种高效且线程安全的方法。在 Java 中，java.util.concurrent.atomic 包提供了多种原子类，其中 AtomicInteger 是最常用的用于实现计数器的类。以下是几种常见的方法来使用 AtomicInteger 实现计数器：

1. 基本计数器

import java.util.concurrent.atomic.AtomicInteger;

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

    // 增加计数
    public void increment() {
        count.incrementAndGet();
    }

    // 减少计数
    public void decrement() {
        count.decrementAndGet();
    }

    // 获取当前计数值
    public int getCount() {
        return count.get();
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicCounter counter = new AtomicCounter();

        // 创建多个线程同时增加计数
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("最终计数值: " + counter.getCount()); // 应该输出 2000
    }
}

解释：

• AtomicInteger 提供了原子操作方法，如 incrementAndGet() 和 decrementAndGet()，这些方法在多线程环境下可以保证操作的原子性，避免竞态条件。
• 在 main 方法中，创建了两个线程同时对计数器进行增加操作，最终的计数值应该是预期的 2000。

2. 使用 getAndIncrement() 和 getAndDecrement()

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

public void decrement() {
    count.getAndDecrement();
}

解释：

• getAndIncrement() 和 getAndDecrement() 方法分别返回增加或减少前的值，然后进行相应的操作。这在某些场景下可能比 incrementAndGet() 更有用。

3. 实现一个线程安全的计数器类

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadSafeCounter {
    private final AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        counter.incrementAndGet();
    }

    public void decrement() {
        counter.decrementAndGet();
    }

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

    // 可选：重置计数器
    public void reset() {
        counter.set(0);
    }
}

4. 使用 AtomicLong 实现高并发计数器

如果计数值可能超过 Integer 的范围，可以使用 AtomicLong：

import java.util.concurrent.atomic.AtomicLong;

public class AtomicLongCounter {
    private final AtomicLong count = new AtomicLong(0);

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

    public void decrement() {
        count.decrementAndGet();
    }

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

5. 扩展：实现一个带有原子更新操作的计数器

有时可能需要基于当前值进行更复杂的更新操作，可以使用 compareAndSet 或其他原子方法：

public boolean incrementIfLessThan(int expectedValue) {
    int current;
    do {
        current = count.get();
        if (current >= expectedValue) {
            return false; // 未达到预期值，不增加
        }
    } while (!count.compareAndSet(current, current + 1));
    return true;
}

解释：

• 这种方法允许在特定条件下进行原子更新，例如只有在当前值小于某个预期值时才增加计数。

6. 使用 LongAdder 提高性能（适用于极高并发）

对于极高并发场景，LongAdder 提供了比 AtomicLong 更好的性能，因为它将总和分散到多个单元中，减少了线程间的竞争。

import java.util.concurrent.atomic.LongAdder;

public class LongAdderCounter {
    private final LongAdder counter = new LongAdder();

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

    public void decrement() {
        counter.decrement();
    }

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

总结：

使用 AtomicInteger 或 AtomicLong 实现计数器可以确保在多线程环境下的线程安全性和高效性。根据具体的应用场景和性能需求，可以选择合适的原子类和方法来实现计数器功能。