Java并发编程中锁、信号量和条件变量的使用示例

原创布满荆棘的人生 2024-09-17 16:15 59阅读 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 final Lock lock = new ReentrantLock();

public void lock() {
        lock.lock();
        System.out.println("Locked the resource.");
    }

public void unlock() {
        lock.unlock();
        System.out.println("Released the locked resource.");
    }
}
```

2. 信号量（Semaphore）

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

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1);

public void acquire() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Acquired the semaphore.");
    }

public void release() throws InterruptedException {
        semaphore.release();
        System.out.println("Released the semaphore.");
    }
}
```

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 final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

public void waitUntilConditionTrue() throws InterruptedException {
        lock.lock();
        try {
            while (!condition.await(1, TimeUnit.SECONDS)))) {
                System.out.println("Waiting for condition to be true...");
            }
            System.out.println("Condition is now true. Exiting.");
            return;
        } finally {
            lock.unlock();
        }
    }

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

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