jdk源码解析七之ReentrantLock

蔚落 2023-02-21 11:41 118阅读 0赞

### 文章目录 ###

*   *  ReentrantLock
     *   *  构造
         *  lock
         *  unlock
         *  tryLock
         *  newCondition
         *  公平策略获取锁
         *  总结
         *  非公平和公平获取锁的区别?

## ReentrantLock ##

一个可重入的互斥锁 Lock  
![在这里插入图片描述][20200603161136741.png]

### 构造 ###

public ReentrantLock() {
        
            //默认初始化非公平的AQS
            sync = new NonfairSync();
        }
    
    
        public ReentrantLock(boolean fair) {
        
            //根据传入的值,选择公平还是非公平的策略
            sync = fair ? new FairSync() : new NonfairSync();
        }

### lock ###

public void lock() {
        
            //调用AQS
            sync.lock();
        }

final void lock() {
        
                //更新state为1
                if (compareAndSetState(0, 1))
                    //设置当前拥有独占访问权限的线程
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    //以独占模式获取对象，忽略中断。
                    acquire(1);
            }

public final void acquire(int arg) {
        
            if (//是否能成功加锁
                    !tryAcquire(arg) &&
                            //阻塞获取锁
                acquireQueued(
                        //将当前线程以及独占模式等待标记,存储到尾端节点
                        addWaiter(Node.EXCLUSIVE)
                        , arg))
                //获取锁的过程中,当出现中断时,会执行到这里
                selfInterrupt();
        }

protected final boolean tryAcquire(int acquires) {
        
                return nonfairTryAcquire(acquires);
            }
            final boolean nonfairTryAcquire(int acquires) {
        
                //获取当前线程
                final Thread current = Thread.currentThread();
                //获取同步状态的值
                int c = getState();
                //说明锁空闲
                if (c == 0) {
        
                  //这个在tryLock调用
                    if (compareAndSetState(0, acquires)) {
        
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
        
                    //也就是这里支持重入锁
                    //当前线程与当前拥有独占访问权限的线程一致
                    //累加state
                    int nextc = c + acquires;
                    if (nextc < 0) // overflow
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }

final boolean acquireQueued(final Node node, int arg) {
        
            boolean failed = true;
            try {
        
                boolean interrupted = false;
                for (;;) {
        
                    //返回前端节点
                    final Node p = node.predecessor();
                    /*如果是当前头节点且再次获取锁成功
                     */
                    if (p == head && tryAcquire(arg)) {
        
                        //设置头结点为当前节点,以及清空当前节点的pre和thread
                        setHead(node);
                        //释放GC
                        p.next = null; // help GC
                        //标记正常执行
                        failed = false;
                        return interrupted;
                    }
                    //检查并修改一个节点的状态，当该节点获取锁失败时。返回true如果线程需要阻塞。
                    if (shouldParkAfterFailedAcquire(p, node) &&
                            //这里执行阻塞
                        parkAndCheckInterrupt())
                        //标记已中断
                        interrupted = true;
                }
            } finally {
        
                if (failed)
                    cancelAcquire(node);
            }
        }

### unlock ###

public void unlock() {
        
            //释放锁
            sync.release(1);
        }

public final boolean release(int arg) {
        
            if (//释放锁,成功则进入
                    tryRelease(arg)) {
        
                //获取head
                Node h = head;
                //如果head不为空,且已经执行
                if (h != null && h.waitStatus != 0)
                    //释放当前节点的下一个节点
                    unparkSuccessor(h);
                return true;
            }
            //释放失败
            return false;
        }

protected final boolean tryRelease(int releases) {
        
                //获取目前锁次数
                int c = getState() - releases;
                //如果当前线程不是当前拥有独占访问权限的线程,说明没有获取锁的情况下unlock,抛出异常
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                //正常释放锁
                if (c == 0) {
        
                    free = true;
                    //清空当前拥有独占锁的线程
                    setExclusiveOwnerThread(null);
                }
                //设置锁次数
                setState(c);
                return free;
            }

private void unparkSuccessor(Node node) {
        
            /*
             * If status is negative (i.e., possibly needing signal) try
             * to clear in anticipation of signalling.  It is OK if this
             * fails or if status is changed by waiting thread.
             */
            int ws = node.waitStatus;
            //重置状态值
            if (ws < 0)
                compareAndSetWaitStatus(node, ws, 0);
    
            /*
             * Thread to unpark is held in successor, which is normally
             * just the next node.  But if cancelled or apparently null,
             * traverse backwards from tail to find the actual
             * non-cancelled successor.
             */
            Node s = node.next;
            //如果下一个节点为null,且状态取消了,则从尾端遍历,查找未取消的线程
            //所以当看到next字段为null时并不意味着当前节点是队列的尾部了。
            //无论如何，如果一个next字段显示为null，我们能够从队列尾向前扫描进行复核。
            if (s == null || s.waitStatus > 0) {
        
                s = null;
                for (Node t = tail; t != null && t != node; t = t.prev)
                    if (t.waitStatus <= 0)
                        s = t;
            }
            if (s != null)
                LockSupport.unpark(s.thread);
        }

### tryLock ###

public boolean tryLock() {
        
            return sync.nonfairTryAcquire(1);
        }

### newCondition ###

public Condition newCondition() {
        
            return sync.newCondition();
        }

### 公平策略获取锁 ###

final void lock() {
        
                //以独占模式获取对象，忽略中断。
                acquire(1);
            }
    
      protected final boolean tryAcquire(int acquires) {
        
                //获取当前线程
                final Thread current = Thread.currentThread();
                int c = getState();
                //锁空闲
                if (c == 0) {
        
                    //判断当前线程是否等待线程队列中的第二个线程
                    //如果是说明等待最久
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
        
                        //设置当前拥有独占访问权限的线程
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
        
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }

public final boolean hasQueuedPredecessors() {
        
            // The correctness of this depends on head being initialized
            // before tail and on head.next being accurate if the current
            // thread is first in queue.
            Node t = tail; // Read fields in reverse initialization order
            Node h = head;
            Node s;
            //判断当前线程是否是等待线程节点的下一个线程
            return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
        }

### 总结 ###

独占锁,支持可重入,每次重入时state+1

### 非公平和公平获取锁的区别? ###

非公平获取锁的时候,不管怎么说,先去抢一波.抢不到再去抢一波,是在抢不到才会添加AQS队列等待.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]  
而公平锁先判断是不是等待最长的线程,如果是则去抢,否则加入队列抢.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 2]

[20200603161136741.png]: https://img-blog.csdnimg.cn/20200603161136741.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200630111357463.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200630111426350.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200630111511450.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70