Java多线程同步问题：锁、信号量及ReentrantLock的实战案例

原创古城微笑少年丶 2024-09-17 11:36 60阅读 0赞

在Java多线程编程中，锁、信号量和`ReentrantLock`都是用于线程同步的重要工具。下面我们将通过实际案例来展示它们的应用。

1. **锁（Synchronized）**：
```java
class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalStateException("Can't decrement to negative value");
        }
    }

// Getters for read-only access
    public synchronized int getCount() {
        return count;
    }
}
```
2. **信号量（Semaphore）**：
```java
import java.util.concurrent.Semaphore;

class CarPark {
    private Semaphore carParkingSpot;

public CarPark(int initialCapacity) {
        this.carParkingSpot = new Semaphore(initialCapacity);
    }

// Method to check if a parking spot is available
    public boolean canPark() throws InterruptedException {
        return carParkingSpot.tryAcquire();
    }

// Method to park a vehicle in the parking spot
    public void parkVehicle() throws InterruptedException {
        carParkingSpot.acquire();
    }
}
```
3. **ReentrantLock（可重入锁）**：
```java
import java.util.concurrent.locks.ReentrantLock;

class ExclusiveResource {
    private ReentrantLock lock;

public ExclusiveResource() {
        this.lock = new ReentrantLock(); // Non-reentrant by default
    }

// Method to acquire exclusive access to the resource
    public void acquireExclusiveAccess() throws InterruptedException {
        if (!lock.tryLock())) { // Try to acquire non-blocking first
            lock.lock(); // If failed, block until lock is available
        }
    }

// Method to release exclusive access to the resource
    public void releaseExclusiveAccess() {
        lock.unlock();
    }
}
```
以上案例展示了锁、信号量以及ReentrantLock在多线程同步中的应用。