【Java 并发】【九】【AQS】【八】ReentrantReadWriteLock之WriteLock写锁原理

public class ReentrantReadWriteLockTest {
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    // 写锁
    private static ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
    // 共享变量
    private static int value = 0;
    
    public static void addValue() {
        try {
            // 修改数据前，加写锁
            writeLock.lock();
            // 修改数据
            value++;
        } finally {
            // 写锁释放
            writeLock.unlock();
        }
    }
}

public void lock() {
    sync.acquire(1);
}

public final void acquire(int arg) {
    // 流程1，进来先调用子类的tryAcquire，这里才是实际上获取资源的实现方法
    // 如果返回false表示获取锁失败，true表示获取锁成功
    if (!tryAcquire(arg) &&
        // 流程2，获取资源失败，则调用addWaiter将当前线程加入AQS的等待队列
        // 流程3，调用acquireQueue方法在AQS等待队列中沉睡，或者再次尝试获取锁
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
    // 获取当前线程
    Thread current = Thread.currentThread();
    // 获取当前读写锁的状态state
    int c = getState();
    // 计算写锁的加锁次数，上一节讲过此方法，保留低16位的值便是写锁个数
    int w = exclusiveCount(c);
    // 如果c!=0，说明有别人加了写锁，或者加了读锁
    if (c != 0) {
        // 1.如果w==0写锁个数为零，说明上面加的锁是读锁，2.当前线程不是获取写锁的线程
        // 这里的意思就是，1.有人加了读锁 2.有人加了写锁，但是加锁的人不是自己，读写、写写互斥，那么自己加锁失败
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        // 走到这里说明w!=0，且current==getExclusiveOwnerThread()说明之前加写锁的人是自己
        // 这里只需要进行重复，增加加锁次数就可以了
        // 同时判断写锁次数最多可以加锁65535次，是否都用完了
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // 重新设置加锁的次数
        setState(c + acquires);
        // 加锁成功返回true
        return true;
    }
    // 走到这里，c == 0 说明读锁、写锁都没有人加
    // writeShouldBlock这里是有公平锁FairSync、非公平锁NonfairSync两种实现
    // 公平锁这里判断AQS等待队列是否有线程在等待，有则不去获取锁，自己也去等待
    // 非公平锁这里直接去尝试获取锁，不管AQS等待队列是否有线程在等待
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    // 走到这里，加锁成功，设置加锁线程为自己
    setExclusiveOwnerThread(current);
    // 返回加锁成功
    return true;
}

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
    // 流程1，直接调用子类的tryRelease方法释放锁
    if (tryRelease(arg)) {
        Node h = head;
        // 流程2，返回true释放成功，唤醒AQS中后一个正在等待的线程
        if (h != null && h.waitStatus != 0)
            // 唤醒头节点后一个正在等待锁的线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    // 这里校验一下，持有锁的是否是当前线程
    // 只允许持有锁的线程释放锁，否则是非法操作
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 这里释放的逻辑就是将加锁的次数减少而已
    int nextc = getState() - releases;
    // 计算释放后的写锁加锁次数，如果写锁的加锁次数为0了，那么说明完全释放了
    boolean free = exclusiveCount(nextc) == 0;
    // 如果写锁完全释放了，则设置加锁的线程为null，也就是没人加锁
    if (free)
        setExclusiveOwnerThread(null);
    // 重写设置锁变量
    setState(nextc);
    return free;
}