锁（八）：ReentrantReadWriteLock之写锁源码实现

• 查看案例

public void inCreate() {
        writeLock.lock();
        try {
            i++;
            Thread.sleep(500L);
            j++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }      

• 查看lock方法

void lock();      

• 查看实现

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

• 查看acquire方法

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}      

• 查看tryAcquire方法

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}      

• 查看tryAcquire方法的实现

@ReservedStackAccess
protected final boolean tryAcquire(int acquires) {
    /*
     * Walkthrough:
     * 1. If read count nonzero or write count nonzero
     *    and owner is a different thread, fail.
     * 2. If count would saturate, fail. (This can only
     *    happen if count is already nonzero.)
     * 3. Otherwise, this thread is eligible for lock if
     *    it is either a reentrant acquire or
     *    queue policy allows it. If so, update state
     *    and set owner.
     */
    Thread current = Thread.currentThread();      // 获取当前线程、获取状态、获取排他锁
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        if (w == 0 || current != getExclusiveOwnerThread())      // 如果是写锁，且当前线程不是持有锁线程
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
        setState(c + acquires);
        return true;
    }
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))  // 如果是非公平锁，就返回false；如果是公平锁，则等待
        return false;
    setExclusiveOwnerThread(current);
    return true;
}      

• 查看释放锁

public void inCreate() {
        writeLock.lock();
        try {
            i++;
            Thread.sleep(500L);
            j++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }      

• 查看unlock方法

void unlock();      

• 查看实现

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

• 查看release方法

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }      

• 查看tryRelease方法

protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}      

• 查看实现

@ReservedStackAccess
protected final boolean tryRelease(int releases) {
    if (!isHeldExclusively())      // 判断持有锁的线程是否是当前线程，不是则抛出异常
        throw new IllegalMonitorStateException();
    int nextc = getState() - releases;
    boolean free = exclusiveCount(nextc) == 0;      // 排他锁次数是否为0
    if (free)
        setExclusiveOwnerThread(null);
    setState(nextc);
    return free;
}