实战：Java中并发编程中的锁和信号量

原创悠悠 2024-11-11 23:33 13阅读 0赞

在Java中，进行并发编程时，锁（Locks）和信号量（Semaphores）是两种常用的同步机制，它们可以帮助我们控制对共享资源的访问，以避免并发问题，如数据竞争和死锁。

###锁（Locks）

Java中的锁通常指的是`synchronized`关键字和`ReentrantLock`类。

- **synchronized关键字**：这是Java内置的同步机制，可以用于方法或代码块。当一个线程访问一个对象的`synchronized`方法或代码块时，它将获得该对象的锁，其他线程将被阻塞，直到当前线程释放锁。

```java public class Counter {
 private int count =0;

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

public synchronized int getCount() {
 return count;
 }
 }
 ```- **ReentrantLock类**：这是`java.util.concurrent.locks`包中的一个类，提供了与`synchronized`关键字类似的同步功能，但它提供了更灵活的锁定机制，比如尝试非阻塞获取锁、可中断的锁获取、超时获取锁等。

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

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

public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }

public int getCount() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
 }
 ```###信号量（Semaphores）

信号量是一种更为通用的同步机制，它允许多个线程同时访问一定数量的资源。

- **Semaphore类**：`java.util.concurrent.Semaphore`类提供了信号量的实现。信号量维护了一组许可，每个`acquire()`调用会消耗一个许可，而每个`release()`调用会释放一个许可。如果许可不足，`acquire()`调用将阻塞，直到有许可可用。

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

public class ResourcePool {
 private final Semaphore semaphore;

public ResourcePool(int permits) {
 semaphore = new Semaphore(permits);
 }

public void useResource() throws InterruptedException {
 semaphore.acquire();
 try {
// 使用资源} finally {
 semaphore.release();
 }
 }
 }
 ```在实际应用中，选择使用锁还是信号量取决于具体的并发需求。锁适用于保护单个资源，而信号量适用于控制对一组资源的访问。正确使用这些同步机制可以提高程序的并发性能和可靠性。