Java并发编程：锁、信号量和条件变量实例

原创 r囧r小猫 2024-12-08 09:33 13阅读 0赞

在Java并发编程中，锁（Lock）、信号量（Semaphore）和条件变量（Condition Variable）是三种常用的同步工具。下面我们将通过实例来理解它们的用法。

1. 锁（Lock）

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

public class LockExample {
    private Lock lock = new ReentrantLock(); // 使用ReentrantLock作为示例

public void acquireLock() {
        lock.acquire();
    }

public void releaseLock() {
        lock.release();
    }
}
```

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

2. 信号量（Semaphore）

```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(1); // 创建一个初始值为1的信号量

public void acquireSemaphore() throws InterruptedException {
        semaphore.acquire();
    }

public void releaseSemaphore() {
        semaphore.release();
    }
}
```

这里，我们创建了一个`Semaphore`对象，并设置其初始值。`acquire()`方法会阻塞当前线程直到获得信号量，而`release()`方法则会释放一个已获得的信号量。

3. 条件变量（Condition Variable）

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

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

public void signal() {
        lock.lock();
        try {
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

public void await() throws InterruptedException {
        lock.lock();
        try {
            condition.await();
        } finally {
            lock.unlock();
        }
    }
}
```

在这个例子中，我们创建了一个`ConditionVariable`。它与`Lock`一起使用，通过`signal()`方法发送信号，以及`await()`方法等待特定条件满足。

以上就是Java并发编程中锁、信号量和条件变量的基本实例和用法理解。