ReentrantReadWriteLock

看看世界_吹吹风
267 阅读6分钟

java.util.concurrent.locks.ReentrantReadWriteLock

  • state高16位表示共享锁； state低16位表示独占锁。

  • 共享锁和独占锁共用一个AQS对象， 共用同一个锁同步队列

共享锁加锁

  • 当前只有共享锁

线程A第一次获取锁 state 0000 0000 0000 0001 0000 0000 0000 0000

相当于 0001（1）

线程A第二次获取锁 state 0000 0000 0000 0010 0000 0000 0000 0000

相当于 0010（2）

类推 0011（3）， 0100（4）

  • state高16位表示共享锁

  • state低16位表示独占锁

  • 如果共享锁可以获取成功， 则不用加入到锁同步队列； 否则， 加入到锁同步队列。

  • state高16位记录获取锁的次数， 不管什么线程， 只要是获取了一次共享锁， 则state高16位就加1， 比如1，2 ， 3， ...等

        static final int SHARED_SHIFT   = 16;

// 0000 0000 0000 0001 0000 0000 0000 0000  
        static final int SHARED_UNIT    = (1 << SHARED_SHIFT);

// 0000 0000 0000 0000 1111 1111 1111 1111 
        static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;

// 0000 0000 0000 0000 1111 1111 1111 1111
//state 低16位表示独占锁
// state 高16位表示共享锁
        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;


protected final int tryAcquireShared(int unused) {
           
            Thread current = Thread.currentThread();
            int c = getState();

// status！=0 表示锁被占用
// 并且锁不是被当前线程占用的
// 获取锁失败， 返回-1， 并退出方法
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return -1;

// 锁空闲、 锁当前被线程占用了 、 
// -----


            int r = sharedCount(c);

            if (!readerShouldBlock() &&
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {
                if (r == 0) { // 锁空闲

                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) { // 锁不空闲且被当前线程占据，并且firstReader是当前线程。


                    firstReaderHoldCount++;

                } else { // 锁不空闲且被当前线程占据，并且firstReader不是当前线程。

// cachedHoldCounter
                    HoldCounter rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))

// 保存非首次的最后一次的获取共享锁的线程
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)  // 释放共享锁， count递减 

                        readHolds.set(rh); //替换
                    rh.count++; // 非首次的获取共享锁的线程，每次获取共享锁都会加1

                }
                return 1;
            }
            return fullTryAcquireShared(current); //cas失败，则自旋获取共享锁。

        }

//        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
// EXCLUSIVE_MASK 0000 0000 0000 0000 1111 1111 1111 1111 
// 返回了count 
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

// c右移16位
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }


// 自旋获取共享锁
 final int fullTryAcquireShared(Thread current) {
         
            HoldCounter rh = null;
            for (;;) {
                int c = getState();
                if (exclusiveCount(c) != 0) {
                    if (getExclusiveOwnerThread() != current)
                        return -1;
                    // else we hold the exclusive lock; blocking here
                    // would cause deadlock.
                } else if (readerShouldBlock()) {
                    // Make sure we're not acquiring read lock reentrantly
                    if (firstReader == current) {
                        // assert firstReaderHoldCount > 0;
                    } else {
                        if (rh == null) {
                            rh = cachedHoldCounter;
                            if (rh == null || rh.tid != getThreadId(current)) {
                                rh = readHolds.get();
                                if (rh.count == 0)
                                    readHolds.remove();
                            }
                        }
                        if (rh.count == 0)
                            return -1;
                    }
                }
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");


// 也第一遍获取共享锁的逻辑一样
// -------- start 
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    if (sharedCount(c) == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        if (rh == null)
                            rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))
                            rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                        cachedHoldCounter = rh; // cache for release
                    }
                    return 1;
                }
            }
        }

共享锁获取

  • 当前state状态是独占锁

  • 线程获取共享锁， 加入到锁同步队列

  • FIFO的同步队列

加入同步队列是， head->trail

共享1， 共享2， 共享3， 独占1， 共享4， 独占2， 共享5

则只能先唤起 共享1， 共享2， 共享3，

当 独占1释放了独占锁之后， 唤起 共享4， 当共享4释放了共享锁之后， 唤起 独占2 独占2释放独占锁之后， 唤起 共享5

public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0) // 当前线程获取共享锁失败

            doAcquireShared(arg); // 加入到同步队列

    }





// 加入到同步队列的操作
    private void doAcquireShared(int arg) {

// 加入到锁同步队列
        final Node node = addWaiter(Node.SHARED);

// 执行获取共享锁和线程挂起的逻辑

        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg); // 如果当前节点的前驱节点是head节点，则尝试获取共享锁。
                    if (r >= 0) { // 获取共享锁成功， 把并把head节点替换成当前节点。
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }

// 执行线程挂起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

加入到锁同步队列

    private Node addWaiter(Node mode) {
// 将节点加入锁同步队列
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }

// 自旋， 将节点加入到锁同步队列
        enq(node);
        return node;
    }


// 自旋， 将节点加入到锁同步队列
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

将head节点替换成当前节点，

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below

    setHead(node); // 把head替换成当前节点。

// propagate > 0 表示当前节点获取共享锁成功
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {

        Node s = node.next; // 当前节点的后续的节点

        if (s == null || s.isShared()) // 如果后续节点也是共享锁节点， 则
            doReleaseShared();
    }
}

private void doReleaseShared() {
     
        for (;;) {
            Node h = head; // 头节点

            if (h != null && h != tail) {
                int ws = h.waitStatus;


                if (ws == Node.SIGNAL) { // 表明h节点曾经被挂起过

                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) // 自旋
                        continue;            // loop to recheck cases

                    unparkSuccessor(h);  // h节点waitStatus改成0成功后， 唤起后继节点
                }
           // h节点的waitStatus已经是0， 且h节点的statusWait设置位Propagate失败， 则自旋

                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }

// 
            if (h == head)                   // loop if head changed
                break;
        }
    }

unparkSuccessor唤起后继节点


    private void unparkSuccessor(Node node) {
      

        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

   
        Node s = node.next; // head节点后继节点

        if (s == null || s.waitStatus > 0) { // 移除waitStatus为cancelled的节点。

            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }


        if (s != null)
            LockSupport.unpark(s.thread); // 唤醒后继节点， 后继节点在doAcquireShared方法中醒来； 并执行tryAcquireShared获取共享锁



    }

共享锁释放锁

  • 只有共享锁线程全部都释放了， 才有必要唤起独占锁线程

 protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            if (firstReader == current) { // 如果是firstReader线程

                // assert firstReaderHoldCount > 0;
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--; // 头一个的线程获取共享锁的次数加1 


            } else { // 非头一个的其他线程

                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove(); //直接从ThreadLocal删除线程

                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count; // 非头一个的当前线程获取共享锁的次数减1

            }

         // state高16位减1
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT; // state高16位减1

                if (compareAndSetState(c, nextc))
                      return nextc == 0; // true, 共享锁全部释放; false, 共享锁正在被当前或者其他线程占用
            }


        }
avatar
文章
阅读
粉丝