并发编程挑战：如何在Java中实现线程安全的计数器？

原创川长思鸟来 2024-10-08 03:21 27阅读 0赞

在Java中实现线程安全的计数器，通常我们会使用synchronized关键字以及Atomic类。以下是一个简单的例子，用AtomicInteger来创建线程安全的计数器：

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

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

public synchronized int increment() {
        return count.incrementAndGet();
    }

public synchronized int decrement() {
        if (count.decrementAndGet() == 0) {
            // 如果计数器变为零，可能需要清理资源
            System.out.println("Counter reached zero, cleaning resources...");
        }
        return count.get();
    }

public static void main(String[] args) {
        ThreadSafeCounter counter = new ThreadSafeCounter();

// 创建两个线程，一个增加，一个减少
        Thread threadIncrement = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        }));

Thread threadDecrement = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        }));

// 启动线程
        threadIncrement.start();
        threadDecrement.start();

// 等待所有线程完成
        try {
            threadIncrement.join();
            threadDecrement.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Final count: " + counter.count.get());
    }
}
```

在这个例子中，我们使用了AtomicInteger作为计数器。synchronized关键字确保了同一时间只有一个线程可以访问和修改这个计数器。