Java并发编程：锁竞态问题示例

原创缺乏、安全感 2024-11-07 04:39 35阅读 0赞

在Java并发编程中，锁竞态（race condition）是指多个线程同时访问共享资源，并且至少有一个线程在修改这个资源时，如果对这些线程的执行顺序不加控制，程序的行为将不确定。下面是一个简单的示例，演示了锁竞态问题：

```javapublic class Counter {
 private int count =0;

public void increment() {
 count++; //这里存在竞态条件 }

public int getCount() {
 return count;
 }

public static void main(String[] args) {
 final Counter counter = new Counter();
Thread[] threads = new Thread[10];

for (int i =0; i <10; i++) {
 threads[i] = new Thread(() -> {
 for (int j =0; j <1000; j++) {
 counter.increment();
 }
 });
 threads[i].start();
 }

for (Thread thread : threads) {
 try {
 thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }

System.out.println("Expected count:10000, Actual count: " + counter.getCount());
 }
}
```在这个例子中，`Counter` 类有一个 `count`变量，`increment` 方法用于增加 `count` 的值。`main` 方法创建了10个线程，每个线程都会调用 `increment` 方法1000次。理论上，`count` 的最终值应该是10000，但由于 `increment` 方法中没有同步机制，多个线程可能会同时读取和写入 `count`变量，导致实际的 `count`值小于10000。

为了解决这个问题，可以使用 `synchronized` 关键字来同步 `increment` 方法，确保每次只有一个线程可以访问这个方法：

```javapublic synchronized void increment() {
 count++;
}
```或者使用 `ReentrantLock`来实现更细粒度的锁控制：

```javaimport java.util.concurrent.locks.ReentrantLock;

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

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

public int getCount() {
 return count;
 }
}
```通过这些同步机制，可以避免锁竞态问题，确保 `count` 的值正确。