java.util.concurrent.Lock指南

1. 概述

简单地说，锁是一种比标准同步代码块更灵活、更复杂的线程同步机制。

Lock接口从Java 1.5开始就存在了。它是在java.util.concurrent.lock包中定义的，提供了广泛的锁定操作。

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

2. 锁和同步块的区别

同步块完全包含在一个方法中，而我们可以在不同的方法中使用Lock API的lock()和unlock()方法。
同步块不支持公平性。一旦释放，任何线程都可以获得锁，并且不能指定优先级。通过指定fairness属性，我们可以在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()类似，只是它会在放弃获取锁之前等待给定的超时时间
void unlock()：释放锁

获取锁之后应始终释放锁以避免出现死锁情况。

建议将使用锁的代码块包含在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接口。它提供了与使用同步方法和语句访问的隐式监视器锁相同的并发性和内存语义，并具有扩展功能。

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

@Slf4j
public class SharedObjectWithLock {
    private final ReentrantLock lock = new ReentrantLock(true);
    private int counter = 0;

    void perform() {
        lock.lock();
        log.info("Thread - " + currentThread().getName() + " acquired the lock");
        try {
            log.info("Thread - " + currentThread().getName() + " processing");
            counter++;
        } catch (Exception exception) {
            log.error(" Interrupted Exception ", exception);
        } finally {
            lock.unlock();
            log.info("Thread - " + currentThread().getName() + " released the lock");
        }
    }
}

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

让我们看看tryLock()是如何工作的：

@Slf4j
public class SharedObjectWithLock {
    private final ReentrantLock lock = new ReentrantLock(true);
    private int counter = 0;

    void performTryLock() {
        log.info("Thread - " + currentThread().getName() + " attempting to acquire the lock");
        try {
            boolean isLockAcquired = lock.tryLock(2, TimeUnit.SECONDS);
            if (isLockAcquired) {
                try {
                    log.info("Thread - " + currentThread().getName() + " acquired the lock");
                    log.info("Thread - " + currentThread().getName() + " processing");
                    sleep(1000);
                } finally {
                    lock.unlock();
                    log.info("Thread - " + currentThread().getName() + " released the lock");
                }
            }
        } catch (InterruptedException e) {
            log.error(" Interrupted Exception ", e);
        }
        log.info("Thread - " + currentThread().getName() + " could not acquire the lock");
    }
}

在这种情况下，调用tryLock()的线程将等待2秒钟，如果锁不可用，它将放弃等待。

4.2 ReentrantReadWriteLock

ReentrantReadWriteLock类实现了ReadWriteLock接口。

让我们看看通过线程获取ReadLock或WriteLock的规则：

读锁：如果没有线程获取或请求写锁，则多个线程可以获取读锁
写锁：如果没有线程在读或写，那么只有一个线程可以获得写锁

让我们看看如何使用ReadWriteLock：

public class SynchronizedHashMapWithRWLock {
    public static final Map<String, String> syncHashMap = new HashMap<>();
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Lock readLock = readWriteLock.readLock();
    private final Lock writeLock = readWriteLock.writeLock();
    public static final Logger LOGGER = LoggerFactory.getLogger(SynchronizedHashMapWithRWLock.class);

    public void put(String key, String value) throws InterruptedException {
        try {
            writeLock.lock();
            LOGGER.info(currentThread().getName() + " writing " + key);
            syncHashMap.put(key, value);
            sleep(1000);
        } 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 {
    public static final Map<String, String> syncHashMap = new HashMap<>();
    private final StampedLock lock = new StampedLock();
    public static final Logger LOGGER = LoggerFactory.getLogger(StampedLockDemo.class);

    public void put(String key, String value) throws InterruptedException {
        long stamp = lock.writeLock();
        try {
            LOGGER.info(currentThread().getName() + " acquired the write lock with stamp " + stamp);
            syncHashMap.put(key, value);
        } finally {
            lock.unlockWrite(stamp);
            LOGGER.info(currentThread().getName() + " unlocked the write lock with stamp " + stamp);
        }
    }

    public String get(String key) throws InterruptedException {
        long stamp = lock.readLock();
        LOGGER.info(currentThread().getName() + " acquired the read lock with stamp " + stamp);
        try {
            sleep(5000);
            return syncHashMap.get(key);
        } finally {
            lock.unlockRead(stamp);
            LOGGER.info(currentThread().getName() + " unlocked the read lock with stamp " + 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. 与Condition使用

Condition类为线程提供了在执行临界区时等待某种条件发生的能力。

当线程获得了对临界区的访问权但不具备执行其操作的必要条件时，就会发生这种情况。例如，一个读线程可以访问一个共享队列的锁，但该队列仍然没有任何数据可使用。

传统上，Java提供wait()、notify()和notifyAll()方法用于线程间通信。

Condition具有类似的机制，但除此之外，我们可以指定多个条件：

public class ReentrantLockWithCondition {
    private static final int CAPACITY = 5;
    private static final Logger LOGGER = LoggerFactory.getLogger(ReentrantLockWithCondition.class);
    private final Stack<String> stack = new Stack<>();
    private final ReentrantLock lock = new ReentrantLock();
    private Condition stackEmptyCondition = lock.newCondition();
    private Condition stackFullCondition = lock.newCondition();

    private void pushToStack(String item) throws InterruptedException {
        try {
            lock.lock();
            if (stack.size() == CAPACITY) {
                LOGGER.info(Thread.currentThread().getName() + " wait on stack full");
                stackFullCondition.await();
            }
            LOGGER.info("Pushing the item " + item);
            stack.push(item);
            stackEmptyCondition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    private String popFromStack() throws InterruptedException {
        try {
            lock.lock();
            if (stack.size() == 0) {
                LOGGER.info(Thread.currentThread().getName() + " wait on stack empty");
                stackEmptyCondition.await();
            }
            return stack.pop();
        } finally {
            stackFullCondition.signalAll();
            lock.unlock();
        }
    }
}

6. 总结

在本文中，我们看到了Lock接口和新引入的StampedLock类的不同实现。

我们还探讨了如何利用Condition类来处理多个条件。

与往常一样，本教程的完整源代码可在GitHub上获得。

Show Disqus Comments