java.util.concurrent.Locks使用指南

1.概述

简而言之，锁是一种比标准同步块更灵活，更复杂的线程同步机制。

自Java 1.5以来，Lock接口一直存在。它在java.util.concurrent.lock包中定义，它提供了大量的锁定操作。

在本文中，我们将探讨Lock接口及其应用程序的不同实现。

2. 锁定(Lock)和同步块(Synchronized )之间的差异

同步块被完全包含在方法中（创建和释放锁在同一个方法内）； Lock可以将lock() 和 unlock()放在不同的方法中
synchronized块不支持公平性，一旦锁释放，任何线程可能获得锁；　　通过指定公平属性，我们可以在Lock API中实现公平。它确保最长的等待线程可以访问锁
如果线程无法访问同步块，则会阻塞该线程； Lock API提供的tryLock（）方法，只有当锁可用且没有任何其他线程持有时，线程才会获取锁定。这减少了线程等待锁定的阻塞时间（可以设置尝试获取锁的时间）
处于“等待”状态以获取对同步块的访问的线程不能被中断； Lock API提供了一种方法lockInterruptibly() ，其可以用来中断等待锁线程。

3. Lock API

我们来看看Lock接口中的方法：

void lock() -获取锁（如果可用）; 如果锁不可用，则线程会被阻塞，直到锁被释放
void lockInterruptibly（） - 这类似于 lock（），但它允许被阻塞的线程被中断并通过抛出的java.lang.InterruptedException恢复执行
boolean tryLock（） - 这是 lock（）方法的非阻塞版本; 它会立即尝试获取锁定，如果锁定成功则返回true
boolean tryLock（long timeout，TimeUnit timeUnit） -这类似于 tryLock（），除了它在放弃尝试获取 Lock之前等待给定的超时
void unlock（） - 解锁Lock实例

执行完毕应始终释放锁以避免死锁情况。使用锁的推荐代码块应包含try / catch和finally块：

Lock lock = ...;
lock.lock();
try {// access to the shared resource
} finally {lock.unlock();
}

除了 Lock接口之外，我们还有一个ReadWriteLock接口，它维护一对锁，一个用于只读操作，另一个用于写操作。只要没有写入，读锁可以由多个线程同时保持。

ReadWriteLock声明获取读或写锁的方法：

Lock readLock（） -返回用于读取的锁
Lock writeLock（） - 返回用于写入的锁

4. 锁的实现

4.1.ReentrantLock（重入锁）

ReentrantLock类实现Lock接口。它提供了相同的并发和内存语义.

public class SharedObject {//...ReentrantLock lock = new ReentrantLock();int counter = 0;public void perform() {lock.lock();try {// Critical section herecount++;} finally {lock.unlock();}}//...
}

我们需要确保在try-finally块中包装lock（）和unlock（）调用以避免死锁情况。

让我们看看tryLock（）如何使用：

public void performTryLock(){//...boolean isLockAcquired = lock.tryLock(1, TimeUnit.SECONDS);if(isLockAcquired) {try {//Critical section here} finally {lock.unlock();}}//...
}

在这种情况下，调用tryLock（）的线程将最多等待一秒钟（如果直接拿到锁则不用等待），并且如果锁不可用则放弃等待。

4.2.ReentrantReadWriteLock

ReentrantReadWriteLock类实现ReadWriteLock接口。

让我们看一下线程获取ReadLock或WriteLock的规则：

读锁 - 如果没有线程获得写锁或请求它，则多个线程可以获取读锁
写锁- 如果没有线程正在读取或写入，则只有一个线程可以获取写入锁

让我们看看如何使用ReadWriteLock：

public class SynchronizedHashMapWithReadWriteLock {Map<String,String> syncHashMap = new HashMap<>();ReadWriteLock lock = new ReentrantReadWriteLock();// ...Lock writeLock = lock.writeLock();public void put(String key, String value) {try {writeLock.lock();syncHashMap.put(key, value);} finally {writeLock.unlock();}}...public String remove(String key){try {writeLock.lock();return syncHashMap.remove(key);} finally {writeLock.unlock();}}//...
}

Lock readLock = lock.readLock();
//...
public String get(String key){try {readLock.lock();return syncHashMap.get(key);} finally {readLock.unlock();}
}public boolean containsKey(String key) {try {readLock.lock();return syncHashMap.containsKey(key);} finally {readLock.unlock();}
}

4.3.StampedLock

StampedLock在Java 8中引入。它还支持读写锁定。但是，锁获取方法会返回一个用于释放锁或检查锁是否仍然有效的戳记：

public class StampedLockDemo {Map<String,String> map = new HashMap<>();private StampedLock lock = new StampedLock();public void put(String key, String value){long stamp = lock.writeLock();try {map.put(key, value);} finally {lock.unlockWrite(stamp);}}public String get(String key) throws InterruptedException {long stamp = lock.readLock();try {return map.get(key);} finally {lock.unlockRead(stamp);}}
}

StampedLock提供的另一个功能是乐观锁定。大多数时候，读操作不需要等待写操作完成，因此不需要真正的读锁。

如果出现并发，我们可以升级到读锁：

public String readWithOptimisticLock(String key) {long stamp = lock.tryOptimisticRead();String value = map.get(key);if(!lock.validate(stamp)) {stamp = lock.readLock();try {return map.get(key);} finally {lock.unlock(stamp);               }}return value;
}

5.使用条件

该条件类提供了一个线程等待在执行关键部分出现一些状况的能力。

当线程获得对临界区的访问但没有执行其操作的必要条件时，可能会发生这种情况。例如，读者线程可以访问共享队列的锁，该队列仍然没有任何数据要消耗。

传统上，Java 为线程互通提供了wait（），notify（）和notifyAll（）方法。条件有类似的机制，但另外，我们可以指定多个条件：

public class ReentrantLockWithCondition {Stack<String> stack = new Stack<>();int CAPACITY = 5;ReentrantLock lock = new ReentrantLock();Condition stackEmptyCondition = lock.newCondition();Condition stackFullCondition = lock.newCondition();public void pushToStack(String item){try {lock.lock();while(stack.size() == CAPACITY) {stackFullCondition.await();}stack.push(item);stackEmptyCondition.signalAll();} finally {lock.unlock();}}public String popFromStack() {try {lock.lock();while(stack.size() == 0) {stackEmptyCondition.await();}return stack.pop();} finally {stackFullCondition.signalAll();lock.unlock();}}
}

对比：

　　Condition提供的方法和Java原生的wait(),notify(),notifyAll()功能类似，但是可以同时创建多个Condition条件，而java原生则不能指定特定的条件。

六，结论

在本文中，我们已经看到了Lock接口和新引入的StampedLock类的不同实现。我们还探讨了如何使用Condition类来处理多个条件。

转载于:https://www.cnblogs.com/gc65/p/10631176.html