并发控制难题：Java多线程同步问题实例

原创港控/mmm° 2024-09-22 14:54 103阅读 0赞

在Java编程中，多线程同步确实是一个常见的难题。以下是一个典型的实例来说明这个问题：

1. **需求**：我们有两个互斥的资源，如两个锁`lock1`和`lock2`。

2. **并发问题**：多个线程同时运行，可能会导致一个线程试图访问已被另一个线程锁定的资源，从而引发死锁或其他同步问题。

3. **解决方案**：
   - 使用锁（互斥量、ReentrantLock等）来保护共享资源。
   - 遵循锁的顺序原则（如Synchronized关键字中的先后顺序），防止循环等待导致死锁。
   
4. **示例代码**（使用ReentrantLock进行同步）：

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

public class ConcurrentExample {
    private final ReentrantLock lock1 = new ReentrantLock();
    private final ReentrantLock lock2 = new ReentrantLock();

public void threadOne() {
        lock1.lock();
        try {
            System.out.println("Thread 1: Acquiring lock1");
            // 独占资源
            // ...
            lock2.lock(); // 同时获取锁2
            System.out.println("Thread 1: Acquired both locks simultaneously.");
            // 共享资源
            // ...
        } finally {
            lock1.unlock();
            System.out.println("Thread 1: Relinquished lock1.");
        }
    }

public void threadTwo() {
        lock2.lock();
        try {
            System.out.println("Thread 2: Acquiring lock2.");
            // 独占资源
            // ...
            lock1.lock(); // 同时获取锁1
            System.out.println("Thread 2: Acquired both locks simultaneously.");
            // 共享资源
            // ...
        } finally {
            lock2.unlock();
            System.out.println("Thread 2: Relinquished lock2.");
        }
    }

public static void main(String[] args) {
        ConcurrentExample example = new ConcurrentExample();
        Thread threadOne = new Thread(() -> example.threadOne()));
        Thread threadTwo = new Thread(() -> example.threadTwo()));

threadOne.start();
        threadTwo.start();

// 主线程等待子线程结束
        try {
            threadOne.join();
            threadTwo.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

这个例子展示了如何使用ReentrantLock进行多线程同步，防止因多个线程同时访问和修改共享资源导致的问题。