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

￡神魔★判官ぃ 2022-12-20 05:38 134阅读 0赞

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

**从释放锁进入**

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);
    }

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

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