java并发编程—ReentrantLock条件变量

最新推荐文章于 2024-03-31 19:03:34 发布

怪我冷i

最新推荐文章于 2024-03-31 19:03:34 发布

阅读量558

点赞数

分类专栏： java 文章标签： java 多线程并发编程 thread 队列

本文链接：https://blog.csdn.net/e891377/article/details/104715461

版权

java 专栏收录该内容

175 篇文章 4 订阅

订阅专栏

java并发编程—ReentrantLock条件变量

每个条件变量其实就对应着一个等待队列，其实现类是ConditionObject

await 流程

开始Thread-0持有锁，调用await，进入ConditionObject的addConditionWaiter流程
创建新的Node状态为-2(Node.CONDITION)，关联Thread-0，加入等待队列尾部
ConditionObject类

        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                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);
        }

addConditionWaiter方法
其中，Node.CONDITION为负2。

        private Node addConditionWaiter() {
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

接下来进入AQS的fullyRelease流程，释放同步器上的锁
在这里插入图片描述
fullyRelease方法

    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
        	//注意，这个saveStae是一个整数值，不一定只是1，有可能发生了锁重入
            int savedState = getState();
            if (release(savedState)) {
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }

release方法，一次减一，一次减一，直到减到零为止。

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

tryRelease方法

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

unpark AQS队列中的下一个节点，竞争锁，假设没有其他竞争线程，那么Thread-1竞争成功。
在这里插入图片描述

signal流程

假设Thread-1要来唤醒Thread-0
signal流程

        public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

判断调用signal的线程是不是锁的持有者，如果不是，则抛出异常。

        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

进入ConditionObject的doSignal流程，取得等待队列中第一个Node，即Thread-0所在Node
在这里插入图片描述
doSignal方法就是把节点从条件变量列表断开。断开以后，相当于被唤醒了，他的条件就满足了。

        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

transferForSignal方法会把节点转移动竞争锁的链表中，如果转移成功，返回真，再取反就是false。
如果转移失败，就看一下firstWaiter是否还有下一个节点，如果有下一个节点，它再尝试唤醒下一个节点。
在这里插入图片描述

    final boolean transferForSignal(Node node) {

        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
		//enq方法把node加到队列最后
        Node p = enq(node);
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }