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

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

从释放锁进入

writeLock.unlock();

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

public final boolean release(int arg) {
    //1、尝试释放锁 返回值代表是否还有写锁 没有返回frue
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //唤醒下一个线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

1、尝试释放锁

protected final boolean tryRelease(int releases) {
    //持有独占锁的线程不是本线程 ，直接抛异常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //获取锁的数量  减去释放的数量
    int nextc = getState() - releases;
    //判断写锁的数量是否为0
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
        //如果不存在写锁，将缓存的写锁置为null
        setExclusiveOwnerThread(null);
    //设置所得数量
    setState(nextc);
    //返回是否还有写锁
    return free;
}

龟龟 这就结束了？好像真的结束了 fair模式下写锁的释放真的好简单啊 比起前面读锁的加锁
为什么这一块这么简单？因为写锁只能一个线程持有，所以也就不会涉及到多线程去处理共享数据的问题了

总结一波

在对源码的研究的时候，我们发现读写锁，不管是公平的还是非公平的，他的加锁的时候，都会尝试去加一次，失败了在尝试一次，还是失败，就将线程放在队列尾结点。这样看来，全都是非公平的。那么真正的公平锁与非公平到底是什么区别呢？我们就且查看以下ReentrantLock的源码来进行简单分析

fair模式下的加锁

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    //锁的数量为0
    if (c == 0) {
        //首先判断当前节点是不是在结点的最前面，也就是紧跟着head结点
        //的确是紧跟着head结点，才会去尝试加锁 否则直接返回false 枷锁失败 入队列
        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;
}

nofair模式下的加锁

final void lock() {
    //话不多说，上手直接加锁
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        //失败的话 调用这个  
        //内部会再次去尝试加锁（使用非公平模式） 如果还是失败，入队列
        acquire(1);
}

在没进入队列之前，他们加锁可能会有区别，但是一旦入队列，那么后续线程唤醒的方式就跟前前面一样了，但是加锁还是按照各自的实现方法去进行。都是大同小异罢了

在纠结要不要整一个加锁的流程图