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 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（）的线程将最多等待一秒钟（如果直接拿到锁则不用等待），并且如果锁不可用则放弃等待。

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类来处理多个条件。