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

蔚落 2022-12-20 05:36 116阅读 0赞

**fair写锁的加锁源码解析**

在上两篇中，我们仔细分析了nofair模式下的读锁的加锁与释放，这里再简单看一下fair模式下的写锁的加锁与释放

**还是从加锁入手**

ReadWriteLock lock = new ReentrantReadWriteLock(true);
        Lock writeLock = lock.writeLock();
        writeLock.lock();
    
    //加锁
    public void lock() { 
        sync.acquire(1);
    }
    
    public final void acquire(int arg) { 
        //1、尝试加锁
        if (!tryAcquire(arg) &&
            //2、加锁失败的话，将其添加到队列中
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

还是熟悉的配方，还是熟悉的味道

**1、尝试加锁**

protected final boolean tryAcquire(int acquires) { 
        
        Thread current = Thread.currentThread();
        int c = getState();
        //排它锁数量
        int w = exclusiveCount(c);
        //存在锁
        if (c != 0) { 
            //不存在写锁 或者获得写锁的线程不是本线程
            if (w == 0 || current != getExclusiveOwnerThread())
                //直接返回false
                return false;
            //存在写锁 并且就是本线程 判断锁数量是否会超过最大的限制
            if (w + exclusiveCount(acquires) > MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            // 重入，再次获得锁 返回true
            setState(c + acquires);
            return true;
        }
        //不存在锁 
        //队列中下一个结点不是本线程的结点 则返回true 也就是 应该阻塞
        //如果返回false，也就是下一次唤醒的就是本线程，那么尝试获取锁。
        if (writerShouldBlock() ||
            !compareAndSetState(c, c + acquires))
            return false;
        //获取锁成功，设置独占锁的线程为本线程
        setExclusiveOwnerThread(current);
        return true;
    }

**2、加锁失败，将其添加到队列中**

final boolean acquireQueued(final Node node, int arg) { 
        boolean failed = true;
        try { 
            boolean interrupted = false;
            for (;;) { 
                //获取前置结点
                final Node p = node.predecessor();
                //前置结点是头节点 
                //再次尝试获取独占锁 也就是再走一遍步骤1
                if (p == head && tryAcquire(arg)) { 
                    //加锁成功 设置为头节点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //以下与读锁的加锁原理的源码分析一致
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally { 
            if (failed)
                cancelAcquire(node);
        }
    }

**至此，独占锁加锁源码分析完毕 。 感觉跟读锁加锁原理几乎一模一样 除了小细节，读锁可以有多个线程去持有，写锁只能一个线程去持有 其他基本一模一样的**