Java并发工具Lock和Condition使用案例

原创秒速五厘米 2024-12-09 07:57 21阅读 0赞

在Java多线程编程中，Lock和Condition是两个非常重要的并发工具，它们分别用于控制共享资源的访问以及线程之间的通信。

1. 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 acquire() {
        try {
            lock.acquire(); // 请求获得锁
            System.out.println("Thread acquired the lock.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void release() {
        try {
            lock.release(); // 释放锁定的资源
            System.out.println("Thread released the lock.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        Thread thread1 = new Thread(example::acquire);
        Thread thread2 = new Thread(example::release);

thread1.start(); // 请求获得锁
        thread2.start(); // 释放锁定的资源

try {
            thread1.join(); // 等待thread1执行完毕
            thread2.join(); // 等待thread2执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，我们创建了一个Lock对象，并通过调用它的acquire()和release()方法来控制锁的获取和释放。

2. Condition（条件）使用案例：

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

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

public void await() throws InterruptedException {
        lock.acquire(); // 请求获得锁

try {
            while (!condition.isReady())) { // 等待条件变为ready
                System.out.println("Waiting for condition to be ready.");
                Thread.sleep(100); // 暂停一秒，模拟等待状态
            }
            condition.signalAll(); // 发送信号通知所有等待的线程
        } finally {
            lock.unlock(); // 释放锁定的资源
        }
    }

public void notify() throws InterruptedException {
        lock.acquire(); // 请求获得锁

try {
            condition.notifyAll(); // 发送信号通知所有等待的线程
            System.out.println("Notified thread to continue.");
        } finally {
            lock.unlock(); // 释放锁定的资源
        }
    }

public static void main(String[] args) {
        ConditionExample example = new ConditionExample();

Thread thread1 = new Thread(example::await));
        Thread thread2 = new Thread(example::notify));

thread1.start(); // 等待条件变为ready
        thread2.start(); // 发送信号通知所有等待的线程

在这个例子中，我们创建了一个Condition对象，用于控制线程的等待和唤醒。通过调用condition的各种方法（如await()和notify()）来实现这些操作。

在main方法中，我们创建了两个线程：一个用于等待条件变为ready，另一个用于发送信号通知所有等待的线程。当所有线程执行完毕后，使用join()方法来阻塞主线程，直到所有子线程都执行完毕。