Java多线程并发编程：同步问题示例

原创逃离我推掉我的手 2024-11-25 23:36 52阅读 0赞

在Java多线程并发编程中，同步问题是常见的挑战。下面给出几个同步问题的示例：

1. **锁竞争**：多个线程尝试获取同一把锁，但资源有限，这会导致线程阻塞。

```java
public class LockRace {
    private Lock lock = new ReentrantLock();

public void thread1() throws InterruptedException {
        lock.lock();
        System.out.println("Thread 1 acquired lock.");
        lock.unlock();
    }

public void thread2() throws InterruptedException {
        lock.lock();
        System.out.println("Thread 2 also acquired lock, lock race detected!");
        lock.unlock();
    }

public static void main(String[] args) {
        LockRace race = new LockRace();
        Thread t1 = new Thread(race::thread1));
        Thread t2 = new Thread(race::thread2));

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

// 等待线程执行完毕
        t1.join();
        t2.join();
    }
}
```

在这个示例中，线程`thread1`和`thread2`试图同时获取锁。由于资源有限，这就导致了锁竞争，从而引发了同步问题。

2. **条件变量**：当一个线程等待另一个线程满足某种条件时，可以使用`Condition`接口的`await()`方法实现。

```java
import java.util.concurrent.Condition;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class ConditionVariableExample {
    private final CountDownLatch signal = new CountDownLatch(1);
    private final Condition ready = new Ready();

public void threadA() throws InterruptedException {
        System.out.println("Thread A: Starting.");
        // 等待信号
        ready.await();
        System.out.println("Thread A: Acquired resource and completed task.");
    }

public void threadB() throws InterruptedException {
        System.out.println("Thread B: Starting.");
        // 发送信号
        signal.countDown();
        System.out.println("Thread B: Sent signal and waited for thread A to be ready.");
        // 等待条件满足
        ready.signalAll(); // 保证所有需要等待的线程都收到信号
        System.out.println("Thread B: Ready signal received, thread A is completed.");
    }

public static void main(String[] args) {
        ConditionVariableExample example = new ConditionVariableExample();
        Thread tA = new Thread(example::threadA));
        Thread tB = new Thread(example::threadB));

tA.start();
        tB.start();

// 等待线程执行完毕
        tA.join();
        tB.join();
    }
}
```

在这个示例中，线程`threadA`等待线程`threadB`发送信号。当`threadB`发出信号并等待`threadA`准备时，就使用了条件变量`ready`。

3. **死锁**：死锁是指两个或更多线程在执行过程中因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法推进下去。