JUC06-读写锁ReentrantReadWriteLock

一、读写锁概述

所谓读写锁，是将锁的类型分为读锁和写锁，但无论是读锁还是写锁，都使用同一个同步器，用同一个state表示锁当前状态。

state：表示当前锁的状态，前16位为写锁标识，后16位为读锁标识，0表示无锁，state的值表示锁重入的次数
Node：若当前线程获取锁失败，则会将其关联到一个新的Node节点添加到阻塞队列中

        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;

        /** waitStatus value to indicate thread has cancelled */
        static final int CANCELLED =  1;
        /** waitStatus value to indicate successor's thread needs unparking */
        static final int SIGNAL    = -1;
        /** waitStatus value to indicate thread is waiting on condition */
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        static final int PROPAGATE = -3;

写锁

上锁

public final void acquire(int arg) {
		//尝试获取锁
        if (!tryAcquire(arg) &&
        	//获取失败则创建node添加至阻塞队列
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
 
 protected final boolean tryAcquire(int acquires) { 
             /*
              1. 如果读标识非0或者写标识非0并且owner非当前线程则失败
              2. 如果count达到最大限制，失败
              3. 如果当前线程是重入锁或者策略允许则可以获得锁，cas修改state并设置owner，成功则返回true否则返回false
              */
            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))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

/**
*将node添加至阻塞队列并阻塞当前线程
*若被打断则返回true，否则返回false
**/
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                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);
        }
    }

释放

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            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;
            boolean free = exclusiveCount(nextc) == 0;
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

读锁

读锁的过程比写锁要复杂，原因是写锁一次只能被一个线程获取，不满足条件时可以直接返回false，而读锁可以被多个线程获取，cas操作失败时不能直接返回false，需要循环判断条件，直到不满足条件时返回false或者cas成功返回true

上锁

public final void acquireShared(int arg) {
		
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }
 /**
 *返回1代表获取读锁成功
 *-1代表失败
 **/
 protected final int tryAcquireShared(int unused) {
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return -1;
            int r = sharedCount(c);
            if (!readerShouldBlock() &&
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {
                //省略不重要的代码
                return 1;
            }
			//循环尝试加读锁，直到写标识不为0且owner不是当前线程或者cas成功
            return fullTryAcquireShared(current);
        }
   
  
    /**
     * Acquires in shared uninterruptible mode.
     * @param arg the acquire argument
     */
    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);
                    if (r >= 0) {
                        //若成功上锁则将该节点设为头结点，并根据条件判断是否唤醒后继节点
                        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);
        }
    }


    /**
     * Sets head of queue, and checks if successor may be waiting
     * in shared mode, if so propagating if either propagate > 0 or
     * PROPAGATE status was set.
     */
    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);
 
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

解锁

 public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
        	//唤醒后继节点
            doReleaseShared();
            return true;
        }
        return false;
    }

tryReleaseShared

// Sync 继承过来的方法, 方便阅读, 放在此处
 protected final boolean tryReleaseShared(int unused) {
	 // ... 省略不重要的代码
	 for (;;) {
		 int c = getState();
		 int nextc = c - SHARED_UNIT;
		 if (compareAndSetState(c, nextc)) {
		 // 读锁的计数不会影响其它获取读锁线程, 但会影响其它获取写锁线程
		 // 计数为 0 才是真正释放
		 	return nextc == 0;
		 }
	 }
}	 

doReleaseShared：唤醒后继节点

private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }