java.util.concurrent.Locks指南

1.概述

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

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

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

2. synchronized 和 Lock 之间的差异

使用synchronized 块和使用Lock API 之间几乎没有区别：

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

3. 锁定 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接口。它提供了相同的并发和内存语义，如使用synchronized方法和语句访问的隐式监视器锁，具有扩展功能。

让我们看看，我们如何使用ReenrtantLock进行同步：

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的规则：

Read Lock - 如果没有线程获取写锁定或请求它，则多个线程可以获取读锁定
Write Lock - 如果没有线程正在读取或写入，则只有一个线程可以获取写锁定
让我们看看如何使用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();
       }
   }
}

6. 结论

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

关注微信公众号：Java知己，
回复关键词 Locks 获取本教程的完整代码。

java.util.concurrent.Locks指南