多线程同步：竞态条件和Lock对象示例

原创逃离我推掉我的手 2024-10-10 20:36 51阅读 0赞

在多线程编程中，同步是非常重要的一环。主要的同步问题包括竞态条件。

**1. 竞态条件**

竞态条件是指多个线程同时访问和修改同一个资源，导致结果不可预知。

例如：
```java
class Counter {
    int count;

synchronized void increment() {
        count++;
    }

synchronized void decrement() {
        count--;
    }
}

// 多线程版本
public class RaceConditionExample {
    private Counter counter = new Counter();

public void race() {
        Thread t1 = new Thread(() -> counter.increment()));
        Thread t2 = new Thread(() -> counter.decrement()));

t1.start();
        t2.start();

try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        RaceConditionExample example = new RaceConditionExample();
        example.race();
        System.out.println("Counter value: " + example.counter.count); // 预期结果为0，说明减法操作没有被执行
    }
}
```
在这个例子中，`Counter`类中的`increment`和`decrement`方法是同步的。线程1尝试增加计数，线程2尝试减少计数。

由于线程同步，如果两个线程同时执行`increment`和`decrement`操作，就会出现竞态条件，导致计数器的值在减法操作后未被正确更新。

**2. Lock对象示例**

Java提供了一些内置的同步工具，如`Lock`接口。以下是一个使用`Lock`实现线程安全的例子：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final Lock lock = new ReentrantLock();

public void criticalSection() {
        try {
            // 获取锁
            lock.lock();
            // 在这里执行线程安全的操作
            System.out.println("Thread safe operation performed.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 无论是否发生异常，都要释放锁
            lock.unlock();
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        example.criticalSection();
    }
}
```
在这个例子中，我们使用了`ReentrantLock`，这是Java中最常用的锁实现之一。在`criticalSection`方法中，获取锁和释放锁的代码确保了线程安全。