Java同步器之ReentrantLock源码解析2

最新推荐文章于 2024-10-18 14:32:41 发布

zhanqinghua123

最新推荐文章于 2024-10-18 14:32:41 发布

阅读量91

点赞数

分类专栏： # 同步器类

本文链接：https://blog.youkuaiyun.com/zhanqinghua123/article/details/119383521

版权

同步器类专栏收录该内容

10 篇文章

订阅专栏

问题

（1）条件锁是什么？

（2）条件锁适用于什么场景？

（3）条件锁的await()是在其它线程signal()的时候唤醒的吗？

简介

条件锁，是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件出现才可以继续处理时使用的一种锁。

比如，在阻塞队列中，当队列中没有元素的时候是无法弹出一个元素的，这时候就需要阻塞在条件notEmpty上，等待其他线程往里面放入一个元素后，唤醒这个条件notEmpty，当前线程才可以继续去做弹出元素的行为。

注意，这里的条件，必须是在获取锁之后去等待，对应到ReentrantLock的条件锁，就是获取锁之后才能调用condition.await()方法。

在Java中，条件锁的实现都是在AQS的ConditionObject类中，ConditionObject实现了Condition接口，下面我们通过一个例子来进入到条件锁的学习中。

public class ReentrantLockTest {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        //条件变量
        Condition condition = lock.newCondition();

        new Thread(()->{
            lock.lock(); //1
            try{
                System.out.println("before await"); //2
                condition.await();    //3
                System.out.println("after await"); //10
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();  //11
            }
        }).start();

        Thread.sleep(1000);
        lock.lock(); //4
        try {
            Thread.sleep(2000);  //5
            System.out.println("before signal");  //6
            //通知条件成立
            condition.signal(); //7
            System.out.println("after signal");   //8
        }finally {
            lock.unlock();  //9
        }
    }
}

上面的代码很简单，一个线程等待条件，另一个线程通知条件已成立，后面的数字代表代码实际运行的顺序，如果你能把这个顺序看懂基本条件锁掌握得差不多了。

源码分析

ConditionObject的主要属性

public class ConditionObject implements Condition, java.io.Serializable {
        private static final long serialVersionUID = 1173984872572414699L;
        /** First node of condition queue. */
        private transient Node firstWaiter;
        /** Last node of condition queue. */
        private transient Node lastWaiter;
}

可以看到条件锁中也维护了一个队列，为了和AQS的队列区分，这里称为条件队列，firstWaiter是队列的头结点，lastWaiter是队列的尾结点。

lock.newCondition()方法

新建一个条件锁

    public Condition newCondition() {
        return sync.newCondition();
    }
    final ConditionObject newCondition() {
        return new ConditionObject();
    }        

    public ConditionObject() { }

新建一个条件锁最后就是调用AQS中的ConditionObject类来实例化条件锁。

condition.await()方法

condition.await()方法，表明要等待条件的出现。

   //AQS中的内部类 ConditionObject类的await()
   public final void await() throws InterruptedException {
        //如果线程中断了  抛出异常
        if (Thread.interrupted())
            throw new InterruptedException();
        //添加到Condition队列中  并返回该节点
        Node node = addConditionWaiter();
        //完全释放当前线程获取的锁
        //因为锁是可重入的，所以这里要把获取的锁全都释放
        int savedState = fullyRelease(node);
        //
        int interruptMode = 0;
        //当前节点是否在同步队列中
        while (!isOnSyncQueue(node)) {
            //阻塞当前线程
            LockSupport.park(this);
            //上面部分是调用await()时释放自己占用的锁，并阻塞自己等待条件的出现

            //下面部分是条件已经出现，尝试去获取锁
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
        }
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        //清除取消的节点
        if (node.nextWaiter != null) // clean up if cancelled
            unlinkCancelledWaiters();
        //线程中断相关
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }

    // AbstractQueuedSynchronizer.ConditionObject.addConditionWaiter
    private Node addConditionWaiter() {
        Node t = lastWaiter;
        // 如果条件队列的尾节点已取消，从头节点开始清除所有已取消的节点
        if (t != null && t.waitStatus != Node.CONDITION) {
            unlinkCancelledWaiters();
            // 重新获取尾节点
            t = lastWaiter;
        }
        // 新建一个节点，它的等待状态是CONDITION
        Node node = new Node(Thread.currentThread(), Node.CONDITION);
        // 如果尾节点为空，则把新节点赋值给头节点（相当于初始化队列）
        // 否则把新节点赋值给尾节点的nextWaiter指针
        if (t == null)
            firstWaiter = node;
        else
            t.nextWaiter = node;
        // 尾节点指向新节点
        lastWaiter = node;
        // 返回新节点
        return node;
    }
    // AbstractQueuedSynchronizer.fullyRelease
    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            // 获取状态变量的值，重复获取锁，这个值会一直累加
            // 所以这个值也代表着获取锁的次数
            int savedState = getState();
            // 一次性释放所有获得的锁
            if (release(savedState)) {
                failed = false;
                // 返回获取锁的次数
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }
    // AbstractQueuedSynchronizer.isOnSyncQueue
    final boolean isOnSyncQueue(Node node) {
        // 如果等待状态是CONDITION，或者前一个指针为空，返回false
        // 说明还没有移到AQS的队列中
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        // 如果next指针有值，说明已经移到AQS的队列中了
        if (node.next != null) // If has successor, it must be on queue
            return true;
        // 从AQS的尾节点开始往前寻找看是否可以找到当前节点，找到了也说明已经在AQS的队列中了
        return findNodeFromTail(node);
    }

这里有几个难理解的点：

1.Condition的队列和AQS的队列不完全一样，AQS的队列头结点是不存在任何值的，是一个虚节点。Condition的队列投机诶单是存储着实实在在的元素值的，是真实节点

2.各种等待状态（waitStatus）的变化；

首先，在条件队列中，新建节点的初始等待状态是CONDITION（-2）；

其次，移到AQS的队列中时等待状态会更改为0（AQS队列节点的初始等待状态为0）；

然后，在AQS的队列中如果需要阻塞，会把它上一个节点的等待状态设置为SIGNAL（-1）；

最后，不管在Condition队列还是AQS队列中，已取消的节点的等待状态都会设置为CANCELLED

另外，后面我们在共享锁的时候还会讲到另外一种等待状态叫PROPAGATE（-3）。

3.相似的名称

AQS中下一个节点是next,上一个节点是prev

Condition中下一个节点是nextWaiter,没有上一个节点

下面总结一下await()方法的大致流程：

（1）新建一个节点加入到条件队列中去；

（2）完全释放当前线程占有的锁；

（3）阻塞当前线程，并等待条件的出现；

（4）条件已出现（此时节点已经移到AQS的队列中），尝试获取锁；

也就是说await()方法内部其实是先释放锁->等待条件->再次获取锁的过程。

condition.signal()方法

    //通知条件出现的方法
    public final void signal() {
        //如果不是当前线程持有锁，调用这个方法会抛出异常
        //说明signal()也是要获取锁之后才执行
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        //条件队列的头结点
        Node first = firstWaiter;
        //如果有等待条件的队列，则通知它条件成立
        if (first != null)
            doSignal(first);
    }        
    private void doSignal(Node first) {
        do {
            //如果头结点后一位的节点为null
            if ( (firstWaiter = first.nextWaiter) == null)
                lastWaiter = null;
            //相当于把头结点出队
            first.nextWaiter = null;
            //转移节点到AQS队列中
        } while (!transferForSignal(first) &&
                 (first = firstWaiter) != null);
    }
    final boolean transferForSignal(Node node) {
        //通过CAS操作把节点的状态改为0，也就是说即将转移到AQS队列中
        //如果失败了，说明当前节点已经被改成取消状态了
        //返回false  通过上面的循环可知会寻找下一个可用节点
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        
        //调用AQS的入队方法将节点放入到AQS对列汇总
        //注意  这里enq()方法返回的是node的上一个节点，也就是旧尾结点
        Node p = enq(node);
        //上一个节点的等待状态
        int ws = p.waitStatus;
        //如果上一个节点已经取消了  或者更新状态为SIGNAL失败(说明上一个节点已经取消了)
        //则直接唤醒当前节点对应的线程
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        // 如果更新上一个节点的等待状态为SIGNAL成功了
        // 则返回true，这时上面的循环不成立了，退出循环，也就是只通知了一个节点
        // 此时当前节点还是阻塞状态
        // 也就是说调用signal()的时候并不会真正唤醒一个节点
        // 只是把节点从条件队列移到AQS队列中

        return true;
    }

signal()方法的大致流程为：

（1）从条件队列的头节点开始寻找一个非取消状态的节点；

（2）把它从条件队列移到AQS队列；

（3）且只移动一个节点；

注意，这里调用signal()方法后并不会真正唤醒一个节点。

总结

（1）重入锁是指可重复获取的锁，即一个线程获取锁之后再尝试获取锁时会自动获取锁；

（2）在ReentrantLock中重入锁是通过不断累加state变量的值实现的；

（3）ReentrantLock的释放要跟获取匹配，即获取了几次也要释放几次；

（4）ReentrantLock默认是非公平模式，因为非公平模式效率更高；

（5）条件锁是指为了等待某个条件出现而使用的一种锁；

（6）条件锁比较经典的使用场景就是队列为空时阻塞在条件notEmpty上；