并发控制：Java中ReentrantLock的使用场景

原创你的名字 2024-09-05 17:54 132阅读 0赞

在Java中，ReentrantLock是一种可重入的互斥锁（Mutex），用于实现多线程环境下的并发控制。

以下是ReentrantLock在常见使用场景中的体现：

1. 同步代码块：
```java
public class Counter {
    private int count = 0;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalArgumentException("Counter is already at zero.");
        }
    }

// ...其他方法
}
```
2. 同步代码块的嵌套：
```java
public class NestedLock {
    private final ReentrantLock outerLock = new ReentrantLock();
    private final ReentrantLock innerLock = new ReentrantLock();

public void doSomething() {
        outerLock.lock(); // 获取外锁

try {
            innerLock.lock(); // 获取内锁

// ...处理业务逻辑
        } catch (InterruptedException e) {
            // ...处理中断情况，释放内锁
            innerLock.unlock();
            e.printStackTrace();
        } finally {
            // 无论是否中断，都需要释放外锁
            outerLock.unlock();
        }
    }

// ...其他方法
}
```
3. 用于保护共享资源的静态方法：
```java
public class ResourceGuard {
    private final ReentrantLock lock = new ReentrantLock();

public static void protectResource(Runnable resource) {
        lock.lock(); // 获取锁

try {
            // ...调用资源共享的业务逻辑
            resource.run();
        } catch (Exception e) {
            e.printStackTrace();
            lock.unlock(); // 释放锁，回滚资源
        } finally {
            lock.unlock(); // 无论是否异常，都释放锁
        }
    }

// ...其他方法
}
```
以上就是在Java中使用ReentrantLock进行并发控制的典型场景。