多线程同步工具：Java并发编程中的Lock、Semaphore使用实例

原创痛定思痛。 2024-10-19 01:39 34阅读 0赞

在Java并发编程中，Lock和Semaphore都是用来实现线程同步的工具。下面我将分别举一个使用实例：

1. Lock（锁）：

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

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

public synchronized void increment() {
        count++;
        lock.unlock(); // 在这里解锁，确保其他线程可以进入
        lock.lock(); // 再次锁住，防止其他线程立即再次访问
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            lock.unlock();
            lock.lock();
        }
        return count;
    }
}
```

在这个例子中，我们创建了一个Counter类，它包含一个可同步的计数器。通过Lock工具，我们可以确保在操作计数器时，不会被其他线程打断。

2. Semaphore（信号量）：

Semaphore主要用于控制同时访问资源的数量。以下是一个简单的示例：

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

class Counter {
    private Semaphore semaphore = new Semaphore(1); // 初始化为最多只有一个线程可以进入

public void increment() throws InterruptedException {
        semaphore.acquire(); // 获取信号量，相当于锁住资源
        System.out.println("Increment by 1"); // 进行操作后释放信号量
        semaphore.release();
    }

public int decrement() throws InterruptedException {
        semaphore.acquire(); // 同样获取信号量
        if (count > 0) { // 如果计数器大于0，进行减法操作
            count--;
            System.out.println("Decrement by 1");
        }
        semaphore.release(); // 释放信号量
        return count;
    }
}
```

在这个例子中，Semaphore用于控制Counter类中的计数器只能被一个线程访问。