简而言之，锁是一种比标准同步块更灵活，更复杂的线程同步机制。
自Java 1.5以来，Lock接口一直存在。它在java.util.concurrent.lock包中定义，它提供了大量的锁定操作。
在本文中，我们将探讨Lock接口及其应用程序的不同实现。
我们来看看Lock接口中的方法：
执行完毕应始终释放锁以避免死锁情况。使用锁的推荐代码块应包含try / catch和finally块：
Lock lock = ...; lock.lock(); try { // access to the shared resource } finally { lock.unlock(); }
除了 Lock接口之外，我们还有一个ReadWriteLock接口，它维护一对锁，一个用于只读操作，另一个用于写操作。只要没有写入，读锁可以由多个线程同时保持。
ReadWriteLock声明获取读或写锁的方法：
ReentrantLock类实现Lock接口。它提供了相同的并发和内存语义.
public class SharedObject { //... ReentrantLock lock = new ReentrantLock(); int counter = 0; public void perform() { lock.lock(); try { // Critical section here count++; } 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（）的线程将最多等待一秒钟（如果直接拿到锁则不用等待），并且如果锁不可用则放弃等待。
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(); } }
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; }
该条件类提供了一个线程等待在执行关键部分出现一些状况的能力。
当线程获得对临界区的访问但没有执行其操作的必要条件时，可能会发生这种情况。例如，读者线程可以访问共享队列的锁，该队列仍然没有任何数据要消耗。
传统上，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类来处理多个条件。
java.util.concurrent.Locks使用指南
原文：https://www.cnblogs.com/gc65/p/10631176.html