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

原创迈不过友情╰ 2024-11-09 00:27 30阅读 0赞

Java并发编程中，锁（Lock）和信号量（Semaphore）是两种常用的同步工具，用于控制多个线程对共享资源的访问。以下是它们的基本使用示例：

###1.锁（Lock）

Java中的`ReentrantLock`类是一个可重入的互斥锁，它提供了与`synchronized`关键字相比更灵活的锁定机制。

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

public class LockExample {
 private final Lock lock = new ReentrantLock();

public void performAction() {
lock.lock(); // 获取锁 try {
//执行需要同步的代码 System.out.println("Performing action");
} finally {
lock.unlock(); //释放锁 }
 }
}
```###2.信号量（Semaphore）

信号量用于控制对资源的访问数量，它可以设置一个许可数量，线程必须获取一个许可才能进入临界区。

```javaimport java.util.concurrent.Semaphore;

public class SemaphoreExample {
 private final Semaphore semaphore = new Semaphore(3); //允许3个线程同时访问 public void performAction() {
 semaphore.acquireUninterruptibly(); // 获取一个许可 try {
//执行需要同步的代码 System.out.println("Performing action");
} finally {
 semaphore.release(); //释放许可 }
 }
}
```### 使用示例以下是如何使用`Lock`和`Semaphore`的示例：

```javapublic class ConcurrencyExample {
 public static void main(String[] args) {
LockExample lockExample = new LockExample();
SemaphoreExample semaphoreExample = new SemaphoreExample();

// 使用Lock new Thread(() -> {
 for (int i =0; i <5; i++) {
lockExample.performAction();
 }
 }).start();

// 使用Semaphore for (int i =0; i <5; i++) {
 new Thread(semaphoreExample::performAction).start();
 }
 }
}
```在这个示例中，`LockExample`类中的`performAction`方法使用`ReentrantLock`来同步访问，而`SemaphoreExample`类中的`performAction`方法使用`Semaphore`来限制同时执行的线程数量。

请注意，这些示例仅用于演示基本用法，实际应用中需要根据具体场景来设计同步策略。同时，使用这些工具时，务必确保在`finally`块中释放锁或信号量，以避免死锁。