多线程同步问题：Java并发编程中的锁、信号量等工具如何使用？

原创喜欢ヅ旅行 2024-11-16 00:21 41阅读 0赞

在Java中，我们通常通过`java.util.concurrent.locks.Lock`接口和其子类（如`ReentrantLock`）来使用锁。

以下是一些基本的使用示例：

1. 获取并锁定锁：
```java
Lock lock = new ReentrantLock();
lock.lock();  // 锁定锁
```
2. 释放已锁定的锁：
```java
try {
    lock.lock();  // 再次锁定锁
    // ...你的代码...
} finally {
    lock.unlock();  // 释放锁定
}
```

信号量（Semaphore）在Java中主要用于线程间的同步，它维护一个可变的计数器。通常用于控制同时访问资源的线程数量。

以下是一个简单的信号量使用示例：

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

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(1);  // 创建一个容量为1的信号量

public void acquireLock() {
        try {
            semaphore.acquire();  // 请求获得信号量，当信号量计数器大于0时，调用此方法会阻塞当前线程，直到其他线程释放了该信号量
            System.out.println("Lock acquired");  // 如果成功获取锁，则打印相关消息
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void releaseLock() {
        try {
            semaphore.release();  // 将信号量的计数器减1，表示线程已释放该资源
            System.out.println("Lock released");  // 如果成功释放锁，则打印相关消息
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        SemaphoreExample semaphoreExample = new SemaphoreExample();

new Thread(() -> semaphoreExample.acquireLock())).start();  // 创建一个新线程来获取锁

try {
            Thread.sleep(2000);  // 线程睡眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

new Thread(() -> semaphoreExample.releaseLock())).start();  // 创建另一个新线程来释放锁

System.out.println("Finished execution");  // 执行完成后打印相关消息
    }
}
```

以上示例中，`Semaphore`用于控制同时访问资源的线程数量。当计数器大于0时，可以获取信号量进行操作；当计数器减至0时，则会阻塞所有正在等待该信号量的线程。