阅读 317

并发编程之——写锁源码分析

1.前言

Java 中的读写锁实现是 ReentrantReadWriteLock ,是一种锁分离策略。能有效提高读比写多的场景下的程序性能。

关于如何使用参见 并发编程之 Java 三把锁

由于读写锁较为复杂,故分为篇文章进行源码分析,今天先说较为简单的写锁。

2. 写锁介绍

不论是读锁还是写锁,都是基于 AQS 的,而 AQS 留给子类实现的就是 tryAcquire 或者 tryAcquireShared 方法,前者是写锁的实现,后者是读锁的实现,从名字上可以看出,一个是独占锁,一个是共享锁。

今天看的就是 tryAcquire 和 tryRelease 的实现,获取和释放。

3. tryAcquire 实现

源码加注释如下:

// 如果有读锁,此时是获取不到写锁的。当有写锁时,判断重入次数。
// 当写锁空闲,读锁空闲,公平模式下,如果队列中有等待的,不会抢锁。非公平模式下,必抢锁。
protected final boolean tryAcquire(int acquires) {
    // 写
    Thread current = Thread.currentThread();
    int c = getState();
    // 用 state & 65535 得到低 16 位的值。
    int w = exclusiveCount(c);
    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        // 如果 state 不是0,且低16位是0,说明了什么?说明写锁是空闲的,读锁被霸占了。那么也不能拿锁,返回 fasle。
        // 如果低 16 位不是0,说明写锁被霸占了,并且,如果持有锁的不是当前线程,那么这次拿锁是失败的。返回 fasle。
        // 总之,当有读锁,就不能获取写锁。当有写锁,就必须是重入锁。
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        // 到这一步了,只会是写重入锁。如果写重入次数超过最大值 65535,就会溢出。
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
        // 将 state  + 1
        setState(c + acquires);
        return true;
    }
    // 当 state 是 0 的时候,那么就可以获取锁了。
    // writerShouldBlock 判断是否需要锁。非公平情况下,返回 false。公平情况下,根据 hasQueuedPredecessors 结果判断。
    // 当队列中有锁等待了,就返回 false 了。
    // 当是非公平锁的时候,或者队列中没有等待节点的时候,尝试用 CAS 修改 state。
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    // 修改成功 state 后,修改锁的持有线程。
    setExclusiveOwnerThread(current);
复制代码

详解的逻辑都写在注释里了,可以对照源码查看,这里再次总结这个方法的逻辑。

  1. 首先判断锁是否空闲。

  2. 如果空闲,则根据公平与否判断是否应该获取锁,当 writerShouldBlock 返回结果是false 的时候,就使用 CAS 修改 state 变量,获取锁。成功之后修改 AQS 持有线程。

  3. 如果不是空闲的,则判断写锁是否是空闲的,这里有 2 种情况:

    3.1 如果写锁空闲,但 state 不是0,说明有读锁,那么就不能获取锁。

    3.2 如果写锁不空闲,判断持有 AQS 锁的线程是不是当前线程,如果不是,不能获取,反之,可以获取重入锁。

4. tryRelease 实现

代码加注释如下:

protected final boolean tryRelease(int releases) {
    // 是否持有当前锁
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 计算 state 值
    int nextc = getState() - releases;
    // 计算写锁的状态,如果是0,说明是否成功。
    boolean free = exclusiveCount(nextc) == 0;
    // 释放成功,设置持有锁的线程为 null。
    if (free)
        setExclusiveOwnerThread(null);
    // 设置 state
    setState(nextc);
    return free;
}
复制代码

这里还是很简单的,只是有一个地方需要注意:

    // 计算写锁的状态,如果是0,说明是否成功。
    boolean free = exclusiveCount(nextc) == 0;
复制代码

这里计算的只是 state 变量的低 16 的值,而不是整个 state 的值。虽然写的时候,必然是串行的,但这里计算的仍然是低 16 位的。

5. 总结

写锁在获取锁的时候,有几个地方需要注意:当有读锁的时候,是不能获取写锁的。写锁可以重入,但不能超过 65535 次。写锁状态设置在 state 变量的低 16 位。

同时,在获取锁的时候,也会根据公平与否决定此次释放需要获取锁。

如果是非公平的,直接尝试CAS 修改 state ,获取锁。

如果是公平的,则根据 hasQueuedPredecessors 方法的返回值判断,也就是如果队列中有等待的线程,则依据公平策略,放弃此次获取锁的操作。反之,直接获取锁。

关注下面的标签,发现更多相似文章
评论
说说你的看法