从读写锁来看抽象队列同步器（释放读锁）

偏执的太偏执、 2022-12-20 03:23 171阅读 0赞

接着上一篇的，在加了锁之后，就到了释放锁的环节

话不多说，直接上源码

**从释放锁进入**

readLock.unlock();
    
    public void unlock() { 
        //还是默认的非公平锁的释放
     	sync.releaseShared(1);
    }

**释放锁**

public final boolean releaseShared(int arg) { 
    	//1、尝试释放锁 如果释放之后， 锁的数量为0 则会执行第2步
        if (tryReleaseShared(arg)) { 
            //2、唤醒其他线程
            doReleaseShared();
            return true;
        }
        return false;
    }

**1、尝试释放锁**

protected final boolean tryReleaseShared(int unused) { 
        Thread current = Thread.currentThread();
        //当前线程是第一个获取读锁的线程
        if (firstReader == current) { 
            //持有的锁的数量为1 直接将firstReader置空
            if (firstReaderHoldCount == 1)
                firstReader = null;
            else
                //将持有的锁的数量-1
                firstReaderHoldCount--;
        } else { 
            //获取缓存的线程持有的锁的计数器
            HoldCounter rh = cachedHoldCounter;
            //不是本线程的计数器
            if (rh == null || rh.tid != getThreadId(current))
                //从threadlocal中获取
                rh = readHolds.get();
            int count = rh.count;
            //持有锁的数量<=1 直接从threadlocal中移除
            if (count <= 1) { 
                readHolds.remove();
                if (count <= 0)
                    throw unmatchedUnlockException();
            }
            //将持有的锁
            --rh.count;
        }
        for (;;) { 
            //获取锁数量
            int c = getState();
            //为什么这么操作呢？ 这就和上锁关联起来了 
            //每加一个锁。state的值就增加SHARED_UNIT 所以每释放一次，也需要减SHARED_UNIT
            int nextc = c - SHARED_UNIT;
            if (compareAndSetState(c, nextc))
                //锁释放成功之后，判断锁的数量是否为0 并且返回
                return nextc == 0;
        }
    }

**2、唤醒其他线程 在分析加锁的时候，2.2 这一块如果下一个结点需要共享锁，则会唤醒这个线程。 同样，在释放掉一个锁之后，也会尝试唤醒下一个结点线程 源码如下**

private void doReleaseShared() { 
        for (;;) { 
            Node h = head;
            //判断队列不为空
            if (h != null && h != tail) { 
                //获取头节点的状态
                int ws = h.waitStatus;
                //等待被唤醒的状态
                if (ws == Node.SIGNAL) { 
                    //将其状态改为0标识本结点不在作用于同步队列 如果失败，进行下一次循环
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    //如果成功，唤醒下一个结点 这一步在上一篇加锁已经分析
                    unparkSuccessor(h);
                }
                //0状态的话 尝试将其修改为-3 失败的话进入下一次循环
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            //这一块为什么这么做？？没搞懂哦
            if (h == head)                   // loop if head changed
                break;
        }
    }

**由上可知，在唤醒线程之后，线程会接着上一步继续往下执行，  
也就是线程会接着parkAndCheckInterrupt()这个之后去往下走，  
因为parkAndCheckInterrupt()让线程暂时堵塞，唤醒之后，就会接着往下走，  
然后在一次去获取他的前置结点，并且尝试获取锁，也就是doAcquireShared()里面的自旋**

到此位置，释放锁就已经结束了 下一篇分析公平模式下的写锁的加锁与释放

**友情参考** https://www.cnblogs.com/waterystone/p/4920797.html