【Java并发工具类】Lock和Condition

前言

Java SDK并发包通过Lock和Condition两个接口来实现管程，其中Lock用于解决互斥问题，Condition用于解决同步问题。我们需要知道，Java语言本身使用synchronized实现了管程的，那么为什么还在SDK中提供另外一种实现呢？欲知为何请看下文。

下面将先阐述再造管程的理由，然后详细介绍Lock和Condition，最后再看实现同步机制时是选择synchronized还是SDK中的管程。

再造管程的理由

Java本就从语言层面实现了管程，然而后面又在SDK中再次现实，这只能说明语言层面的实现的管程有所不足。要说谈synchronized的不足，我们就要要回顾一下破坏死锁的不可抢占问题：

破坏不可抢占条件，需要线程在获取不到锁的情况下主动释放它拥有的资源。当我们使用synchronized的时候，线程是没有办法主动释放它占有的资源的。因为，synchronized在申请不到资源时，会使线程直接进入阻塞状态，而线程进入了阻塞状态就不能主动释放占有的资源。

所以，有没有一种办法可以使得线程处于阻塞状态时也能够响应中断主动释放资源或者获取不到资源的时候不阻塞呢？答案是有的，使用SDK中的管程。

SDK中管程的实现java.util.concurrent中的Lock接口，提供了如下三种设计思想都可以解决死锁的不可抢占条件：

  1. 能够响应中断

    线程处于阻塞状态时可以接收中断信号。我们便可以给阻塞的线程发送中断信号，唤醒线程，线程便有机会释放它曾经拥有的锁。这样便可破坏不可抢占条件。

  2. 支持超时

    如果线程在一段时间之内没有获取到锁，不是进入阻塞状态，而是返回一个错误，那这个线程也有机会释放曾经持有的锁。这样也能破坏不可抢占条件。

  3. 非阻塞地获取锁

    如果尝试获取锁失败，并不进入阻塞状态，而是直接返回，那这个线程也有机会释放曾经持有的锁。这样也可以破坏不可抢占条件。

这三种方案就可全面弥补synchronized的问题。也就是再造管程的原因。这三种思想体现在Lock接口的API上，便是如下三个方法：

// 支持中断的 API
void lockInterruptibly() throws InterruptedException;

// 支持超时的 API
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

// 支持非阻塞获取锁的 API
boolean tryLock();

下面我们便继续介绍Lock。

Lock和ReentrantLock

Lock接口中定义了一组抽象的加锁操作：

public interface Lock{
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition(); // 关联Condition对象使用
}

与synchronized内置加锁不同，Lock提供的是无条件的、可轮询的、定时的以及可中断的锁获取操作，所有加锁和解锁都是显式的。在Lock的实现中必须要提供与内置锁相同的内存可见性语义，但是加锁语义、调度算法、顺序保证以及性能等方面可以不同。

ReentrantLock实现了Lock接口，并提供了与synchronized相同的互斥性和内存可见性。在获取ReentrantLock时，有着进入同步代码块相同的内存语义，在释放ReentrantLock时，同样有着与退出同步代码块相同的内存语义。见名知义，ReentrantLock还提供了同synchronized一样的可重入加锁的语义。

?? 扩展：可重入函数
可重入函数怎么理解呢？指的是线程可以重复调用？显然不是，所谓可重入函数，指的是多个线程可以同时调用该函数，每个线程都能得到正确结果；同时在一个线程内支持线程切换，无论被切换多少次，结果都是正确的。多线程可以同时执行，还支持线程切换，这意味着什么呢？线程安全。所以，可重入函数是线程安全的。

Lock的标准使用形式

Lock l = ...; //使用ReentrantLock实现类 Lock l = new ReentrantLock();
l.lock();
try {
    // access the resource protected by this lock
} finally {
    l.unlock();
}

Lock的使用形式比synchronized要复杂一些，所有的加锁和解锁的操作都是显式的。解锁操作必须在finally块中，否则，如果在被保护的代码块中抛出了异常，那么这个锁将永远无法释放。当使用加锁时，还必须考虑在try块中抛出异常的情况，如果可能使对象处于不一致状态，那么就需要try-catch或者try-finally块。

轮询锁与定时锁

可定时与可轮询的锁获取方式是由tryLock方法实现的。与无条件获取锁的模式比较，它具有更完善的错误恢复机制。

使用轮询锁解决动态顺序死锁问题

如果不能获得所有需要的锁，那么可以使用可定时的或者可轮询的锁获取方式，它会释放已经获得的锁，然后尝试重新获取所有锁。下面一个例子（来自参考[2]），给出了使用轮询锁来解决转账时动态顺序死锁问题：使用tryLock来获取两个账户的锁，如果不能同时获得，那么就回退并重新尝试。程序中还在休眠时间中做了随机处理，从而降低发生活锁的可能性。

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import static java.util.concurrent.TimeUnit.NANOSECONDS;

public class DeadlockAvoidance {
    private static Random rnd = new Random();
    public boolean transferMoney(Account fromAcct,
                                 Account toAcct,
                                 DollarAmount amount,
                                 long timeout,
                                 TimeUnit unit)
        throws InsufficientFundsException, InterruptedException {
        long fixedDelay = getFixedDelayComponentNanos(timeout, unit);
        long randMod = getRandomDelayModulusNanos(timeout, unit);
        long stopTime = System.nanoTime() + unit.toNanos(timeout);

        while (true) {
            // 使用tryLock()获取锁,如果获取了锁，则返回 true；否则返回 false.
            if (fromAcct.lock.tryLock()) {
                try {
                    if (toAcct.lock.tryLock()) { // 使用tryLock()获取锁
                        try {
                            if (fromAcct.getBalance().compareTo(amount) < 0)
                                throw new InsufficientFundsException();
                            else {
                                fromAcct.debit(amount);
                                toAcct.credit(amount);
                                return true;
                            }
                        } finally {
                            toAcct.lock.unlock();
                        }
                    }
                } finally {
                    fromAcct.lock.unlock();
                }
            }
            if (System.nanoTime() < stopTime) // 获取锁的时间大于给定时间,则返回失败
                return false;
            NANOSECONDS.sleep(fixedDelay + rnd.nextLong() % randMod); // 休眠时间加入随机成分
        }
    }

    private static final int DELAY_FIXED = 1;
    private static final int DELAY_RANDOM = 2;

    static long getFixedDelayComponentNanos(long timeout, TimeUnit unit) {
        return DELAY_FIXED;
    }

    static long getRandomDelayModulusNanos(long timeout, TimeUnit unit) {
        return DELAY_RANDOM;
    }

    static class DollarAmount implements Comparable<DollarAmount> {
        public int compareTo(DollarAmount other) {
            return 0;
        }
        DollarAmount(int dollars) {
        }
    }

    class Account {
        public Lock lock;
        void debit(DollarAmount d) {
        }
        void credit(DollarAmount d) {
        }
        DollarAmount getBalance() {
            return null;
        }
    }
    class InsufficientFundsException extends Exception {
    }
}

定时锁

在实现具有时间限制操作时，定时锁将非常有用。当在带有时间限制的操作中调用了一个阻塞方法时，它能根据剩余时间来提供一个时限。如果操作不能在指定的时间内给出结果，那么它就会使程序提前结束。当使用内置锁时，在开始请求锁后，这个操作将无法取消，因此内置锁很难实现带有时间限制的操作。

可中断的锁获取操作

可中断的锁获取操作适用在可取消的操作中获取锁。内置锁是不能响应中断的。lockInterruptibly()方法能够在获取锁的同时保持对中断的响应，因为它包含在Lock中，因此无须创建其他类型的不可中断阻塞机制。

非块结构的加锁

在内置锁中，锁的获取和释放都是基于代码块的，且是自动获取和释放锁。虽然这样避免了编码的复杂性，但是却不太灵活。例如，某些遍历并发访问的数据结果的算法要求使用连锁式加锁"hand-over-hand" 或锁耦合 "chain locking"：获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放 B 并获取 D，依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁，从而支持使用这种技术。

公平性

在ReentrantLock的构造函数中提供了两种公平性选择：创建一个非公平的锁（默认）或者一个公平的锁。

public ReentrantLock(){}
// fair参数代表的是锁的公平策略，如果传入true就表示需要构造一个公平锁，否则就是构造一个非公平锁。
public ReentrantLock(boolean fair) {}

在公平的锁上，线程将按照它们发出请求的顺序来获得锁；在非公平的锁上，则允许“插队”：当一个线程请求非公平锁时，如果在发出请求的同时该锁的状态变为可用，那么这个线程将跳过队列中所有的等待线程并获得这个锁（来得早不如来得巧）。

关于请求线程是否进入队列排队等待锁：在公平的锁中，如果有一个线程持有这个锁或者有其他线程正在队列中等待这个锁，那么新发出请求的线程将被放入队列中等待（FIFO原则）；在非公平锁中，只有当锁被某个线程持有时，新发出请求的线程才会被放入队列中（如上面所述的来得巧就会直接获得锁）。

在现实生活中我们往往期望事事公平，但是为什么在并发的锁上却存在不公平锁？其实想想也简单，恢复挂起的一个线程到这个线程到这个线程真正开始执行之前是存在延迟的，如果在此期间有一个线程刚好达到并且在被唤醒的线程真正执行之前又刚好可以利用完资源，那么这种充分利用资源的精神恰恰是可取的。
公平性将由于在挂起线程和恢复线程时产生开销而极大地降低性能，于是，大多数情况下，非公平锁的性能要高于公平锁的性能。

只有当持有锁的时间相对较长，或者请求锁的平均时间间隔较长，那么就应该使用公平锁。与默认的ReentrantLock一样，内置加锁并不会提供确定的公平性保证。

synchronized和ReentrantLock之间的抉择

ReentrantLock在加锁和内存上提供的语义都与内置锁相同，除此之外，它还提供我们上述的定时的锁等待、可中断的锁等待、公平性以及实现非块结构的加锁。ReentrantLock在性能上也优于内置锁（在Java 5.0中远远胜出，在Java 6.0中略有胜出，synchronized在Java 6.0中做了优化），但是是否就意味着开发都使用ReentrantLock替代synchronized呢？

synchronized与ReentrantLock相比，还是具有很大优势。例如为开发人员所熟悉、简洁紧凑。加锁和释放锁都是自动进行的，而显式锁需要手动在finally中进行，如果忘记将引发严重后果。在现有很多程序中使用的时内置锁，贸然混合入显式锁也会让人困惑，也容易引起错误。

所以，在一般情况下使用内置锁，仅当内置锁不能满足需求时，才可以考虑使用ReentrantLock。未来synchronized被提升优化的可能也会很大，因为synchronized作为JVM的内置属性，可以便于一些代码优化，如对线程封闭的锁对象的锁消除优化，通过增加锁的粒度来消除内置锁的同步。

Condition对象

Lock可以看作是一种广义的内置锁，Condition则可以看作是一种广义的内置条件队列。我们前面介绍管程时说过，每个内置锁只能有一个相关联的条件队列（条件变量等待队列）。 一个Condition和一个Lock关联在一起，就像一个条件队列和一个内置锁关联一样。创建一个Condition，可以在关联的Lock上调用Lock.newCondition()方法 。Condition比内置条件队列提供了更丰富的功能：在每个锁上加锁存在多个等待、条件等待是可中断的或不可中断的、基于限时的等待，以及公平的或非公平的队列操作。

每个Lock可以拥有任意数量的Condition对象。Condition对象继承了相关的Lock对象的公平性，对于公平的锁，线程会依照FIFO顺序从Condition.await中释放。

Condition的接口如下：

public interface Condition{
    void await() throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    void awaitUninterruptibly();
    boolean awaitUntil(Date deadline) throws InterruptedException;
    void signal();
    void signalAll();
}

注意，在Condition对象中，与（等待—唤醒机制中介绍的）内置锁中wait、notify、notifyAll方法相对应的是await、signal、signaAll方法。因为Condition也继承了Object，所以它也包含了wait、notify和notifyAll方法，在使用时一定要使用正确的版本。

使用Lock和Condition实现有界缓存（代码来自参考[2]）。使用两个Condition，分别为notFull和notEmpty，用于表示“非满”与“非空”两个条件谓词（使某个操作成为状态依赖操作的前提，对下面的take方法来说，它的条件谓词就是“缓存不空”，take方法在执行前必须首先测试该条件谓词）。当缓存为空时，take将阻塞并等待notEmpty，此时put想notEmpty发送信号，可以解除任何在take中阻塞的线程。

public class ConditionBoundedBuffer <T> {
    protected final Lock lock = new ReentrantLock();
    // 条件谓词: notFull (count < items.length)
    private final Condition notFull = lock.newCondition();
    // 条件谓词: notEmpty (count > 0)
    private final Condition notEmpty = lock.newCondition();
    private static final int BUFFER_SIZE = 100;
    @GuardedBy("lock") private final T[] items = (T[]) new Object[BUFFER_SIZE];
    @GuardedBy("lock") private int tail, head, count;

    // 阻塞并直到: notFull
    public void put(T x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await(); // 阻塞当前线程在notFull的条件队列上
            items[tail] = x;
            if (++tail == items.length)
                tail = 0;
            ++count;
            notEmpty.signal(); // 唤醒notEmpty条件队列上的一个线程
        } finally {
            lock.unlock();
        }
    }

    // 阻塞并直到: notEmpty
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await(); // 阻塞当前线程在notEmpty的条件队列上
            T x = items[head];
            items[head] = null;
            if (++head == items.length)
                head = 0;
            --count;
            notFull.signal(); // 唤醒notFull条件队列上的一个线程
            return x;
        } finally {
            lock.unlock();
        }
    }
}

通过将两个条件谓词分开并放到两个等待线程集中，Condition使其更容易满足单次通知的需求。signal将比signalAll更高效，它能极大地减少在每次缓存操作中发生的上下文切换与锁请求的次数。因为如果使用内置锁来实现，所有被阻塞的线程都将在一个队列上等待。

小结

在开发并发程序时，是使用原生的synchronized还是java.util.concurrent.*下的显式锁Lock工具类，它们各有优劣还需要根据具体要求进行选择。以上仅是学习笔记的整合，若有不明不白之处，还望各位看官指出，先在此谢过。

参考:
[1]极客时间专栏王宝令《Java并发编程实战》
[2]Brian Goetz.Tim Peierls. et al.Java并发编程实战[M].北京:机械工业出版社,2016

原文地址：https://www.cnblogs.com/myworld7/p/12288315.html

时间： 2024-08-27 12:40:53

【Java并发工具类】Lock和Condition的相关文章

Java并发工具类 - CountDownLatch

Java并发工具类 - CountDownLatch 1.简介 CountDownLatch是Java1.5之后引入的Java并发工具类,放在java.util.concurrent包下面 http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html 官方API. CountDownLatch能够使一个或多个线程等待其他线程完成各自的工作后再执行:CountDownLatch是JDK 5+里面

Java并发工具类CyclicBarrier

CyclicBarrier同步屏障 java并发工具类中有一个叫做CyclicBarrier的类,与CountDownLatch类似,都可以实现线程间的同步,但是差别是CyclicBarrier是可重置的同步屏障. 想象一个场景,有N个人不同时间走到一扇门,因为门需要N个人合力才能推开,所以人不足N个时,只能阻塞在此,等到N个人都到了之后,可以推开门,继续进行之前的工作.CyclicBarrier就是这扇门. 看看下面的代码,定义了一个线程数为2的,CyclicBarrier,并在主线程和另外一

25.大白话说java并发工具类-CountDownLatch，CyclicBarrier,Semaphore，Exchanger

1. 倒计时器CountDownLatch 在多线程协作完成业务功能时,有时候需要等待其他多个线程完成任务之后,主线程才能继续往下执行业务功能,在这种的业务场景下,通常可以使用Thread类的join方法,让主线程等待被join的线程执行完之后,主线程才能继续往下执行.当然,使用线程间消息通信机制也可以完成.其实,java并发工具类中为我们提供了类似"倒计时"这样的工具类,可以十分方便的完成所说的这种业务场景. 为了能够理解CountDownLatch,举一个很通俗的例子,运动员进行跑

【Java并发工具类】Semaphore

前言 1965年,荷兰计算机科学家Dijkstra提出的信号量机制成为一种高效的进程同步机制.这之后的15年,信号量一直都是并发编程领域的终结者.1980年,管程被提出,成为继信号量之后的在并发编程领域的第二个选择.目前几乎所有的语言都支持信号量机制,Java也不例外.Java中提供了Semaphore并发工具类来支持信号量机制.下面我们就来了解Java实现的信号量机制. 首先介绍信号量模型,然后介绍如何使用,最后使用信号量来实现一个限流器. 信号量模型 信号量模型图(图来自参考[1]): 信号

【Java并发工具类】Java并发容器

前言 Java并发包有很大一部分都是关于并发容器的.Java在5.0版本之前线程安全的容器称之为同步容器.同步容器实现线程安全的方式:是将每个公有方法都使用synchronized修饰,保证每次只有一个线程能访问容器的状态.但是这样的串行度太高,将严重降低并发性,当多个线程竞争容器的锁时,吞吐量将严重降低.因此,在Java 5.0版本时提供了性能更高的容器来改进之前的同步容器,我们称其为并发容器. 下面我们先来介绍Java 5.0之前的同步容器,然后再来介绍Java 5.0之后的并发容器. Ja

Java并发工具类（四）：线程间交换数据的Exchanger

简介 Exchanger(交换者)是一个用于线程间协作的工具类.Exchanger用于进行线程间的数据交换.它提供一个同步点,在这个同步点两个线程可以交换彼此的数据.这两个线程通过exchange方法交换数据, 如果第一个线程先执行exchange方法,它会一直等待第二个线程也执行exchange,当两个线程都到达同步点时,这两个线程就可以交换数据,将本线程生产出来的数据传递给对方. Exchanger的应用场景 1.Exchanger可以用于遗传算法,遗传算法里需要选出两个人作为交配对象,这时

Java并发工具类（一）等待多线程完成的CountDownLatch

作用 CountDownLatch是一个同步工具类,它允许一个或多个线程一直等待,直到其他线程的操作执行完后再执行 简介 CountDownLatch是在java1.5被引入的,存在于java.util.concurrent包下,它允许1个或者多个线程一直等待,直到一组操作执行完成.它初始一个整数值,此值是线程将要等待的操作数.当某个线程为了想要执行这些操作而等待时, 它要使用 await()方法.此方法让线程进入休眠直到操作完成. 当某个操作结束,它使用countDown() 方法来减少Cou

Java并发工具类（四）线程间交换数据的Exchanger

简介 Exchanger(交换者)是一个用于线程间协作的工具类.Exchanger用于进行线程间的数据交换.它提供一个同步点,在这个同步点两个线程可以交换彼此的数据.这两个线程通过exchange方法交换数据, 如果第一个线程先执行exchange方法,它会一直等待第二个线程也执行exchange,当两个线程都到达同步点时,这两个线程就可以交换数据,将本线程生产出来的数据传递给对方. Exchanger的应用场景 1,Exchanger可以用于遗传算法,遗传算法里需要选出两个人作为交配对象,这时

【多线程与并发】Java并发工具类

主要有两类 ①并发流程控制相关:CountDownLatch.CyclicBarrier.Semaphore ②线程间交换数据相关:Exchanger: CountDownLatch 作用:允许一个或多个线程等待其他线程完成操作 使用步骤: ①定义一个CountDownLatch(称为计数器),并指定等待次数: ②在合适的时机将计数器减1: ③在需要等待所有任务结束的位置,调用await()方法: 根据JDK中的说明文档整理的两个例子: 例子1: public class CountDownLa