Java多线程同步问题：锁、信号量和条件变量实战

原创曾经终败给现在 2024-09-19 11:51 95阅读 0赞

在Java多线程编程中，锁（Lock）、信号量（Semaphore）和条件变量（Condition Variable）是三种常用的同步工具。

1. 锁（Lock）：
   - `synchronized`关键字实现同步。
   - 适用于互斥访问资源的场景。
   
2. 信号量（Semaphore）：
   - 定义一个资源，资源数量有限。
   - 当线程需要使用资源时，通过`wait()`方法减小资源计数，然后进入等待状态；当资源可用时，通过`signal()`或`notifyAll()`方法增加资源计数，唤醒等待的线程。
   
3. 条件变量（Condition Variable）：
   - 用于实现线程间的同步条件，比如：两个线程需要互斥执行某个操作，或者等待特定事件发生等场景。
   - 当满足某些条件时，线程可以通过`wait()`方法进入等待状态；当条件不满足或某个线程通知其他线程时，可以通过`notifyAll()`或`notify()`方法唤醒等待的线程。

实战示例：
```java
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MultiThreadSynchronization {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

public void syncWithSignal() throws InterruptedException {
        lock.lock();

try {
            System.out.println("线程1等待...");

// 线程2到达，通过条件变量唤醒线程1
            if (condition.signalAll()) {
                System.out.println("线程1被唤醒并执行...");

// 模拟耗时操作
                Thread.sleep(3000);
            }
        } finally {
            lock.unlock();
        }
    }

public static void main(String[] args) {
        MultiThreadSynchronization sync = new MultiThreadSynchronization();

new Thread(() -> {
            try {
                sync.syncWithSignal();
                System.out.println("线程2执行完毕...");

} catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 在这里可以模拟其他操作，不影响主线程
        })).start();

// 主线程等待子线程执行完毕
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("主线程执行完毕...");
    }
}
```
在这个例子中，我们创建了两个线程：`线程1`和`线程2`。线程1等待条件满足后（由线程2唤醒），执行耗时操作。

在主程序中，主线程会等待子线程执行完毕，然后执行自己的业务逻辑。