Java多线程同步问题：信号量与锁对比案例

原创绝地灬酷狼 2024-11-06 06:54 19阅读 0赞

在Java中，多线程同步是一个重要的概念，它确保了多个线程在访问共享资源时的一致性和线程安全。信号量（Semaphore）和锁（Lock）是两种常用的同步机制，它们在某些方面有相似之处，但在使用场景和功能上有所不同。下面我将通过一个简单的案例来对比这两种同步机制。

###案例背景假设我们有一个资源池，资源池中有固定数量的资源。多个线程需要从资源池中获取资源进行处理，处理完毕后释放资源。我们需要确保在任何时刻，访问资源池的线程数量不超过资源池的大小。

### 使用锁（Lock）

Java中的`ReentrantLock`是一个可重入的互斥锁，可以用来实现线程同步。

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

public class LockExample {
 private final Lock lock = new ReentrantLock();
 private int permits =5; //资源池大小 public void process() {
lock.lock();
 try {
if (permits >0) {
 System.out.println(Thread.currentThread().getName() + " 获取资源");
 permits--;
//模拟处理过程Thread.sleep(1000);
 System.out.println(Thread.currentThread().getName() + "释放资源");
 permits++;
 }
} finally {
lock.unlock();
 }
 }

public static void main(String[] args) {
LockExample example = new LockExample();
 for (int i =0; i <10; i++) {
 new Thread(() -> example.process(), "Thread-" + i).start();
 }
 }
}
```### 使用信号量（Semaphore）

`Semaphore`是一个计数信号量，用于控制对资源池的访问数量。

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

public class SemaphoreExample {
 private final Semaphore semaphore;
 private int permits =5; //资源池大小 public SemaphoreExample() {
 semaphore = new Semaphore(permits);
 }

public void process() {
 try {
 semaphore.acquire();
 System.out.println(Thread.currentThread().getName() + " 获取资源");
//模拟处理过程Thread.sleep(1000);
 System.out.println(Thread.currentThread().getName() + "释放资源");
 semaphore.release();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
 }
 }

public static void main(String[] args) {
SemaphoreExample example = new SemaphoreExample();
 for (int i =0; i <10; i++) {
 new Thread(() -> example.process(), "Thread-" + i).start();
 }
 }
}
```### 对比1. **功能**：
- **锁（Lock）**：主要用于保护临界区，确保同一时间只有一个线程可以访问。
- **信号量（Semaphore）**：用于控制对资源池的访问数量，可以有多个线程同时访问。

2. **使用场景**：
- **锁**：适用于需要互斥访问的场景。
- **信号量**：适用于需要限制资源访问数量的场景。

3. **灵活性**：
- **锁**：提供了更多的灵活性，如尝试锁定、定时锁定等。
- **信号量**：功能相对简单，主要用于控制资源访问数量。

4. **性能**：
- 在某些情况下，信号量的性能可能优于锁，因为它的实现更轻量级。

选择使用锁还是信号量，需要根据具体的应用场景和需求来决定。