ReentrantLock Condition 分析

女爷i 2022-12-11 13:52 121阅读 0赞

### 文章目录 ###

*  前言
 *  一、Condition类结构
 *  二、源码分析
 *   *  获得对象流程
     *  await 流程
     *  signal 流程

--------------------

# 前言 #

Condition可以快速的帮助我们实现条件阻塞需求

--------------------

# 一、Condition类结构 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]

`await`:释放当前持有锁,然后进入休眠  
`signal`:唤醒进入休眠的线程

其中有两个重要字段`firstWaiter`和`lastWaiter`。这两个字段会在`ConditionObject`中构造一个新的链表，用于存在`await`后休眠的线程，笔者在本文中称为，`等候队列(等候列表)`。而最原始的`AQS`链表笔者称为`获取锁队列`

public class ConditionObject {
        
     //...
     //...
            private transient Node firstWaiter;
            private transient Node lastWaiter;
    //...
    //...
    }

# 二、源码分析 #

## 获得对象流程 ##

ReentrantLock reentrantLock = new ReentrantLock(false);
     Condition condition = reentrantLock.newCondition();

//ReentryLock.java
     public Condition newCondition() {
        
            return sync.newCondition();
        }

//java.util.concurrent.locks.ReentrantLock.Sync
     final ConditionObject newCondition() {
        
           return new ConditionObject();
    }

我们可以看到最终获取到的实例对象为:  
`java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject`

## await 流程 ##

简单`Demo`:

public class Main {
        
    
        public static void main(String[] args) throws InterruptedException {
        
    
            ReentrantLock reentrantLock = new ReentrantLock(false);
    
            Condition condition = reentrantLock.newCondition();
    
            Thread thread = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        reentrantLock.lock();
                        System.out.println("子线程释放锁，并休眠");
                        condition.await();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println("子线程被唤醒");
                }
            });
    
            thread.start();
            TimeUnit.SECONDS.sleep(1);
    
            reentrantLock.lock();
            System.out.println("主线程获取到锁");
            condition.signal();
            reentrantLock.unlock();
            System.out.println("主线程释放锁 并通知阻塞线程");
    
        }
    }

`await流程`:

//ConditionObject.java
     public final void await() throws InterruptedException {
        
                //中断处理
                if (Thread.interrupted())
                    throw new InterruptedException();
                //构造一个Node添加到等候队列    
                Node node = addConditionWaiter();
                //当前线程释放锁
                int savedState = fullyRelease(node);
                //标志当前是否中断
                int interruptMode = 0;
                //判断当前节点是否在获取锁队列，
                //注意,AQS等候获取锁队列我们称为 获取锁队列.condition中的队列我们称之为等候队列（wait-Sets）
                //所以当前节点在获取锁队列，那么证明被其他线程唤醒了。
                while (!isOnSyncQueue(node)) {
        
                    LockSupport.park(this);
                    //checkInterruptWhileWaiting 内部处理逻辑。如果中断就将当前节点从 
                    // <等候队列>移动到 <获取锁队列>,而后返回
                    if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                        break;
                }
                //acquireQueued获取锁
                if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                    interruptMode = REINTERRUPT;
                
                //当前节点被取消那么清清除操作
                if (node.nextWaiter != null) // clean up if cancelled
                    unlinkCancelledWaiters();
                //如果被中断了，那么抛出中断异常出去
                if (interruptMode != 0)
                    reportInterruptAfterWait(interruptMode);
            
            }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 1]

**总结：**  
1、线程await后一直循环到当前线程节点Node从Condition的等候队列移动到AQS队列中  
2、移动AQS队列后在此自旋直到获取到锁返回

从`Condition`的等候队列移动到`AQS`队列中有两种方式：  
1、当前线程被中断原因取消。  
2、当前线程对应Node被其他线程调用同一`Condition`对象实例的`signal`函数.

## signal 流程 ##

//ConditionObject.java
    public final void signal() {
        
    			//当前线程必须是持有有锁线程
                if (!isHeldExclusively())
                    throw new IllegalMonitorStateException();
                //第一个等候队列中的元素
                Node first = firstWaiter;
                
                if (first != null)
                    doSignal(first);
    }

//ConditionObject.java
    
      private void doSignal(Node first) {
        
                do {
        
                	//下一个元素为空的话，那么把尾结点也置空
                    if ( (firstWaiter = first.nextWaiter) == null)
                        lastWaiter = null;
                     
                    //置空头结点的下一个元素，    
                    first.nextWaiter = null;
                } while (!transferForSignal(first) &&
                         (first = firstWaiter) != null);
            }

final boolean transferForSignal(Node node) {
        
            /*
             * 
             * 如果节点不能改变证明已经被取消
             */
            if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
                return false;
    
            /*
             *	拼接到AQS的获取锁队列中并且尝试设置入队后返回的前一个节点waitStatus状态，
             *	以标识线程可能正在等候。如果前节点被取消或者设置waitStatus失败。那么让
             *	前任节点重新获取一次锁。
             */
            Node p = enq(node);
            int ws = p.waitStatus;
            if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
                LockSupport.unpark(node.thread);
            return true;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/1d54bc9399dc4f609a943075d5890ffb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/581aab6934174de19e4c81de5c306cc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/e9ad849f765547d79a44f4584a8e38d8.png