Java多线程同步工具Lock及问题示例

原创心已赠人 2024-11-07 15:24 10阅读 0赞

Java中的`Lock`接口是`java.util.concurrent.locks`包中的一部分，提供了比`synchronized`关键字更灵活的线程同步控制。以下是`Lock`接口的一些关键特性和使用示例：

###1. `Lock`接口的主要方法：

- `void lock()`：获取锁。
- `void unlock()`：释放锁。
- `boolean tryLock()`：尝试获取锁，如果锁被其他线程占用，则立即返回`false`。
- `boolean tryLock(long timeout, TimeUnit unit)`：尝试获取锁，如果锁被其他线程占用，则等待指定的时间，如果超时仍未获得锁，则返回`false`。
- `Condition newCondition()`：返回一个`Condition`对象，可以用于实现等待/通知模式。

###2. `ReentrantLock`类：

`ReentrantLock`是`Lock`接口的一个实现，支持重入，即同一个线程可以多次获取同一个锁。

###3. 使用示例：

#### 示例1：基本的锁获取和释放```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SimpleLockExample {
 private final Lock lock = new ReentrantLock();

public void performAction() {
lock.lock(); // 获取锁 try {
//执行需要同步的代码} finally {
lock.unlock(); //释放锁 }
 }
}
```#### 示例2：尝试获取锁```javapublic void performAction() {
if (lock.tryLock()) {
 try {
//执行需要同步的代码} finally {
lock.unlock();
 }
} else {
//处理获取锁失败的情况 }
}
```#### 示例3：带超时的尝试获取锁```javapublic void performAction() {
 long timeout =1000; //等待1秒if (lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
 try {
//执行需要同步的代码} finally {
lock.unlock();
 }
} else {
//处理获取锁失败的情况 }
}
```#### 示例4：使用`Condition`实现等待/通知模式```javapublic class BoundedBuffer {
 private final Lock lock = new ReentrantLock();
 private final Condition notFull = lock.newCondition();
 private final Condition notEmpty = lock.newCondition();
 private final Object[] items = new Object[100];
 private int putptr, takeptr, count;

public void put(Object x) throws InterruptedException {
lock.lock();
 try {
 while (count == items.length) {
 notFull.await();
 }
 items[putptr] = x;
if (++putptr == items.length) putptr =0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
 }
 }

public Object take() throws InterruptedException {
lock.lock();
 try {
 while (count ==0) {
notEmpty.await();
 }
Object x = items[takeptr];
if (++takeptr == items.length) takeptr =0;
--count;
 notFull.signal();
 return x;
} finally {
lock.unlock();
 }
 }
}
```###4.问题示例：

- **死锁**：当两个或多个线程相互等待对方释放锁时，可能会发生死锁。
- **资源浪费**：如果一个线程长时间持有锁，可能会导致其他线程长时间等待，造成资源浪费。
- **优先级反转**：低优先级的线程持有锁，而高优先级的线程需要这个锁，可能导致优先级反转问题。

使用`Lock`时，需要仔细设计以避免这些问题。