Java多线程同步工具类：Lock和Condition实例

原创不念不忘少年蓝@ 2024-10-07 05:36 64阅读 0赞

在Java中，我们通常使用`java.util.concurrent.locks.Lock`接口来实现线程的同步。而`java.util.concurrent.locks.Condition`接口则用于实现线程间的通信。

以下是一个简单的例子，展示了如何创建`Lock`和`Condition`实例：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; // 这里使用了可重入锁
import java.util.concurrent.locks.Condition;

public class MultiThreadSync {
    private Lock lock = new ReentrantLock(); // 创建锁
    private Condition condition = lock.newCondition(); // 创建条件

public void printWhenReady() throws InterruptedException {
        lock.lock(); // 获取锁

try {
            if (!condition.await(5, TimeUnit.SECONDS))) { // 如果5秒后没有满足条件，则抛出InterruptedException
                System.out.println("Ready after 5 seconds");
                }
            else {
                System.out.println("Ready when condition matched");
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

public static void main(String[] args) throws InterruptedException {
        MultiThreadSync sync = new MultiThreadSync();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println("Produced: " + i);
                    if (i == 5) { // 当生产到第五个元素时，通知消费者
                        sync.condition.signalAll(); // 使用signalAll()方法一次性唤醒所有等待的线程
                        }
                    Thread.sleep(100); // 模拟耗时操作
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        })});
        Thread consumer = new Thread(() -> {
            try {
                sync.printWhenReady(); // 当条件匹配时，打印"Ready when condition matched"
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Consumer thread exiting...");
        })});
        producer.start(); // 启动生产者线程
        consumer.start(); // 启动消费者线程

// 主程序等待所有线程执行完毕
        while (!producer.isDone() || !consumer.isDone()) {
            try {
                Thread.sleep(1000); // 模拟程序繁忙，减少主线程的占用
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```

在这个例子中，我们创建了一个`Lock`实例（代表一把锁）和一个`Condition`实例（代表一个条件）。生产者线程会尝试获取锁并满足条件，然后释放锁。消费者线程则会在满足条件时打印一条消息，并退出。

在`main`方法中，我们启动了生产者线程和消费者线程，并等待所有线程执行完毕。