Ô´Âë·ÖÎö¡ª java¶ÁдËøReentrantReadWriteLock

Ç°ÑÔ

½ñÌì¿´JraftµÄʱºò·¢ÏÖÁ˺ܶàµØ·½¶¼Óõ½Á˶ÁдËø£¬365betÌåÓýÔÚÏßÐÄѪÀ´³±ÏëÒª·ÖÎöÒÔ϶ÁдËøÊÇÔõôʵÏֵġ£

ÏÈÉÏÒ»¸ödocÀïÃæµÄÀý×Ó£º

class CachedData {
  Object data;
  volatile boolean cacheValid;
  final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

  void processCachedData() {
	  //¼ÓÉÏÒ»¸ö¶ÁËø
    rwl.readLock().lock();
    if (!cacheValid) {
      // Must release read lock before acquiring write lock
      //±ØÐëÔÚ¼ÓдËø֮ǰÊͷŶÁËø
      rwl.readLock().unlock();
      rwl.writeLock().lock();
      try {
        // Recheck state because another thread might have
        // acquired write lock and changed state before we did.
		  //Ë«Öؼì²é
        if (!cacheValid) {
			//ÉèÖÃÖµ
          data = ...
          cacheValid = true;
        }
        // Downgrade by acquiring read lock before releasing write lock
		  //Ëø½µ¼¶£¬·´Ö®Ôò²»ÐÐ
        rwl.readLock().lock();
      } finally {
		  //ÊÍ·ÅдËø£¬µ«ÊÇÈÔÈ»³ÖÓÐдËø
        rwl.writeLock().unlock(); // Unlock write, still hold read
      }
    }

    try {
      use(data);
    } finally {
		//ÊͷŶÁËø
      rwl.readLock().unlock();
    }
  }
}}

365betÌåÓýÔÚÏßÃÇÒ»°ãʵÀý»¯Ò»¸öReentrantReadWriteLock£¬Ò»°ãÊǵ÷ÓÿյĹ¹ÔìÆ÷´´½¨£¬365betÌåÓýÔÚÏßĬÈÏʹÓõÄÊǷǹ«Æ½Ëø

public ReentrantReadWriteLock() {
    this(false);
}


public ReentrantReadWriteLock(boolean fair) {
	  //ĬÈÏʹÓõÄÊÇNonfairSync
    sync = fair ? new FairSync() : new NonfairSync();
    readerLock = new ReadLock(this);
    writerLock = new WriteLock(this);
}
//·Ö±ðµ÷ÓÃwriteLockºÍreadLock»á·µ»Ø¶ÁдËøʵÀý
public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

ReentrantReadWriteLockÄÚ²¿ÀàSync

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 6317671515068378041L;
 	  //λÒÆÁ¿
	  //ÔÚ¶ÁдËøÖУ¬stateÊÇÒ»¸ö32λµÄint£¬365betÌåÓýÔÚÏßÓÃstateµÄ¸ß16λ365ÌåÓýͶע¶ÁËø£¬ÓõÍ16λ365ÌåÓýͶעдËø
    static final int SHARED_SHIFT   = 16;
	  //ÒòΪ¶ÁËøÊǸß16룬365betÌåÓýÔÚÏßÓÃ1Ïò×óÒƶ¯16λ365ÌåÓýͶע¶ÁËøÿ´ÎËø״̬±ä»¯µÄÁ¿
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
	  //×î´óµÄ¿ÉÖØÈë´ÎÊý
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
	  //ÓÃÀ´¼ÆËãµÍ16λµÄдËø״̬
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

    //»ñÈ¡¸ß16λ¶ÁËøstate´ÎÊý£¬ÖØÈë´ÎÊý
    static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
    //»ñÈ¡µÍ16λдËøstate´ÎÊý£¬ÖØÈë´ÎÊý
    static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

    //ÓÃÀ´¼Ç¼365ÌåÓýͶעÏ̳߳ÖÓеĶÁËøÊýÁ¿
    static final class HoldCounter {
        int count = 0;
        // Use id, not reference, to avoid garbage retention
        final long tid = getThreadId(Thread.currentThread());
    }

    
    static final class ThreadLocalHoldCounter
        extends ThreadLocal<HoldCounter> {
        public HoldCounter initialValue() {
            return new HoldCounter();
        }
    }

    private transient ThreadLocalHoldCounter readHolds;
 	  // ÓÃÓÚ»º´æ£¬¼Ç¼"×îºóÒ»¸ö»ñÈ¡¶ÁËøµÄÏß³Ì"µÄ¶ÁËøÖØÈë´ÎÊý
    private transient HoldCounter cachedHoldCounter;
 	  // µÚÒ»¸ö»ñÈ¡¶ÁËøµÄÏß³Ì(²¢ÇÒÆäδÊͷŶÁËø)£¬ÒÔ¼°Ëü³ÖÓеĶÁËøÊýÁ¿
    private transient Thread firstReader = null;
    private transient int firstReaderHoldCount;

    Sync() {
		  // ³õʼ»¯ readHolds Õâ¸ö ThreadLocal ÊôÐÔ
        readHolds = new ThreadLocalHoldCounter();
        setState(getState()); // ensures visibility of readHolds
    }
	....
}

1. ÒòΪintÊÇ32λµÄ£¬365betÌåÓýÔÚÏßÔÚReentrantReadWriteLockÖн«state·ÖΪÁ½²¿·Ö£¬¸ß16λ×÷Ϊ¶ÁËøµÄ״̬¿ØÖÆÆ÷£¬µÍ16λ×÷ΪдËøµÄ״̬¿ØÖÆÆ÷¡£
2. ÿ´365betÌåÓýÔÚÏߪ»ñÈ¡¶ÁËøµÄµ±Ç°×´Ì¬¶¼ÐèÒªµ÷ÓÃsharedCount´«È뵱ǰµÄstate£¬½«stateÏòÓÒÒƶ¯16λÀ´»ñÈ¡
3. Òª»ñÈ¡µÍ16λÔòÐèÒª½«1×óÒÆ16λ¼õÒ»£¬»ñµÃÒ»¸öµÍ16λȫÊÇ1µÄÊý£¬È»ºóºÍ´«ÈëµÄstate½øÐÐÈ¡Óë²Ù×÷»ñÈ¡stateµÄµÍ16λµÄÖµ
4. cachedHoldCounterÀïÃæ±£´æÁË×îеĶÁËøµÄÏ̺߳͵÷ÓôÎÊý
5. firstReader ºÍ firstReaderHoldCount ½«¡±µÚÒ»¸ö¡±»ñÈ¡¶ÁËøµÄÏ̼߳ǼÔÚ firstReader ÊôÐÔÖУ¬ÕâÀïµÄµÚÒ»¸ö²»ÊÇÈ«¾ÖµÄ¸ÅÄµÈÕâ¸ö firstReader µ±Ç°´ú±íµÄÏß³ÌÊͷŵô¶ÁËøÒԺ󣬻áÓкóÀ´µÄÏß³ÌÕ¼ÓÃÕâ¸öÊôÐԵġ£

¶ÁËø»ñÈ¡

//readLock#lock
public void lock() {
	  //ÕâÀï»áµ÷Óø¸ÀàAQSµÄacquireShared£¬³¢ÊÔ»ñÈ¡Ëø
    sync.acquireShared(1);
}
//AQS#acquireShared
public final void acquireShared(int arg) {
	  //·µ»ØֵСÓÚ 0 ´ú±íûÓлñÈ¡µ½¹²ÏíËø
    if (tryAcquireShared(arg) < 0)
		  //½øÈëµ½×èÈû¶ÓÁУ¬È»ºóµÈ´ýÇ°Çý½Úµã»½ÐÑ
        doAcquireShared(arg);
}

ÕâÀïµÄtryAcquireSharedÊǵ÷ÓÃReentrantReadWriteLockµÄÄÚ²¿ÀàSyncµÄtryAcquireSharedµÄ·½·¨

protected final int tryAcquireShared(int unused) {
 	  //»ñÈ¡µ±Ç°Ïß³Ì
    Thread current = Thread.currentThread();
	  //»ñÈ¡AQSÖеÄstateÊôÐÔÖµ
    int c = getState();
    //exclusiveCount·½·¨ÊÇÓÃÀ´»ñȡдËø״̬£¬²»µÈÓÚ0´ú±íÓÐдËø
    if (exclusiveCount(c) != 0 &&
		  //Èç¹û²»Êǵ±Ç°Ï̻߳ñÈ¡µÄдËø£¬ÄÇôֱ½Ó·µ»Ø-1
        getExclusiveOwnerThread() != current)
        return -1;
	  //»ñÈ¡¶ÁËøµÄËø¶¨´ÎÊý
    int r = sharedCount(c);
	  // ¶ÁËø»ñÈ¡ÊÇ·ñÐèÒª±»×èÈû
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        //ÒòΪ¸ß16λ´ú±í¹²ÏíËø£¬365betÌåÓýÔÚÏßCASÐèÒª¼ÓÉÏÒ»¸öSHARED_UNIT
        compareAndSetState(c, c + SHARED_UNIT)) {
        if (r == 0) {
			  //¼Ç¼һÏÂÊ״ζÁÏß³Ì
            firstReader = current;
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
			   //firstReader ÖØÈë»ñÈ¡¶ÁËø
            firstReaderHoldCount++;
        } else {
            HoldCounter rh = cachedHoldCounter;
			  // Èç¹û cachedHoldCounter »º´æµÄ²»Êǵ±Ç°Ị̈߳¬ÉèÖÃΪ»º´æµ±Ç°Ïß³ÌµÄ HoldCounter
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0)
                readHolds.set(rh);
            rh.count++;
        }
		   // return ´óÓÚ 0 µÄÊý£¬´ú±í»ñÈ¡µ½Á˹²ÏíËø
        return 1;
    }
    return fullTryAcquireShared(current);
}

1. Ê×ÏÈ»áÈ¥µ÷ÓÃexclusiveCount·½·¨À´²é¿´Ð´ËøÊÇ·ñ±»Õ¼Óã¬Èç¹û±»Õ¼Óã¬ÄÇô²é¿´µ±Ç°Ïß³ÌÊÇ·ñÊÇÕ¼ÓöÁËøµÄỊ̈߳¬Èç¹û²»ÊÇÔò·µ»Ø-1¡£Í¨¹ýÕâÀï¿ÉÒÔ¿´³ö¿ÉÒÔÏÈÕ¼ÓöÁËøÔÙÕ¼ÓÃдËø
2. µ÷ÓÃreaderShouldBlock·½·¨»ñÈ¡ÊÇ·ñÐèÒª×èÈû¶ÁËø»ñÈ¡£¬È»ºó¼ì²éһϸß16λ¶ÁËøÖØÈë´ÎÊýÊÇ·ñ³¬¹ýÁË2^16-1£¬×îºóͨ¹ýCAS²Ù×÷½«state¸ß16½øÐмÓ1²Ù×÷£¬Èç¹ûûÓÐÆäËûÏß³ÌÇÀÕ¼¾Í»á³É¹¦
3. Èç¹ûstateµÄ¸ß16λΪÁ㣬ÄÇô¾ÍÉèÖÃÊ״ζÁÏ̺߳ÍÊ×´ÎÊý´ÎÊý£¬Èç¹û²»ÊÇÔòУÑéÊ״ζÁÏß³ÌÊDz»Êǵ±Ç°Ị̈߳¬ÊǵĻ°½«firstReaderHoldCount´ÎÊý¼Ó1¡£Èç¹û²»ÊÇÊ״ζÁỊ̈߳¬ÄÇôУÑéÒ»ÏÂ×îºóÒ»´Î¶ÁÏß³ÌÊDz»Êǵ±Ç°Ị̈߳¬²»ÊǵĻ°¾Í´ÓreadHoldsÖлñÈ¡£¬²¢½«HoldCounter¼ÆÊý¼Ó1£¬Èç¹û×îºó¶ÁÏß³ÌÊǵ±Ç°Ïß³ÌÄÇô¼ÆÊý¼Ó1

readerShouldBlock

//NonfairSync#readerShouldBlock
final boolean readerShouldBlock() {
    return apparentlyFirstQueuedIsExclusive();
}
//AQS
final boolean apparentlyFirstQueuedIsExclusive() {
    Node h, s;
    return (h = head) != null &&
        (s = h.next)  != null &&
        !s.isShared()         &&
        s.thread != null;
}

Ôڷǹ«Æ½Ä£Ê½ÖÐreaderShouldBlock»áµ÷ÓÃAQSµÄ·½·¨£¬Åжϵ±Ç°Í·½ÚµãµÄÏÂÒ»¸ö½Úµã£¬Èç¹û²»Êǹ²Ïí½Úµã£¬ÄÇôreaderShouldBlock¾Í·µ»Øtrue£¬¶ÁËø¾Í»á×èÈû¡£

//FairSync#readerShouldBlock
final boolean readerShouldBlock() {
    return hasQueuedPredecessors();
}
//AQS
public final boolean hasQueuedPredecessors() {
   
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

ÔÚ¹«Æ½Ä£Ê½ÖлáÈ¥¿´¿´¶ÓÁÐÀïÓÐûÓÐÆäËûÔªËØÔÚ¶ÓÁÐÀïµÈ´ý»ñÈ¡Ëø£¬Èç¹ûÓÐÄÇô¶ÁËø¾Í½øÐÐ×èÈû

ReentrantReadWriteLock#fullTryAcquireShared

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
			  //Ê״ζÁÏß³ÌÊǵ±Ç°Ị̈߳¬ÏÂÃæÖ±½ÓCAS
            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)
							   //Èç¹û·¢ÏÖ count == 0£¬Ò²¾ÍÊÇ˵£¬´¿ÊôÉÏÒ»ÐдúÂë³õʼ»¯µÄ£¬ÄÇôִÐÐ remove
                            readHolds.remove();
                    }
                }
				   //Èç¹û×îºó¶ÁÈ¡Ï̴߳ÎÊýΪ0£¬ÄÇô×èÈû
                if (rh.count == 0)
                    return -1;
            }
        }
		  //Èç¹û¶ÁËøÖØÈë´ÎÊý´ïµ½ÉÏÏÞ£¬Å×Òì³£
        if (sharedCount(c) == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
		  //³¢ÊÔCAS¶ÁËøÖØÈë´ÎÊý¼Ó1
        if (compareAndSetState(c, c + SHARED_UNIT)) {
			   // ÕâÀï CAS ³É¹¦£¬ÄÇô¾ÍÒâζ×ųɹ¦»ñÈ¡¶ÁËøÁË
            // ÏÂÃæÐèÒª×öµÄÊÇÉèÖà firstReader »ò cachedHoldCounter
            if (sharedCount(c) == 0) {
                firstReader = current;
                firstReaderHoldCount = 1;
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
				  // ÏÂÃæÕ⼸ÐУ¬¾ÍÊǽ« cachedHoldCounter ÉèÖÃΪµ±Ç°Ïß³Ì
                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
            }
			  // ·µ»Ø´óÓÚ 0 µÄÊý£¬´ú±í»ñÈ¡µ½Á˶ÁËø
            return 1;
        }
    }
}

Õâ¸ö·½·¨Ö÷ÒªÊÇÓÃÀ´´¦ÀíÖØÈëËø²Ù×÷µÄ¡£Ê×ÏÈУÑéÒ»ÏÂдËøÊÇ·ñ±»Õ¼Óã¬Èç¹ûûÓб»Õ¼ÓÃÔòÅжϵ±Ç°Ïß³ÌÊÇ·ñÊǵÚÒ»´Î¶ÁỊ̈߳¬Èç¹û²»ÊÇÔòÅжÏ×îºóÒ»´Î¶ÁÏß³ÌÊDz»Êǵ±Ç°Ị̈߳¬Èç¹û²»ÊÇÔò´ÓreadHolds»ñÈ¡£¬²¢ÅжÏHoldCounterʵÀýÖлñÈ¡¶ÁËø´ÎÊýÈç¹ûΪ0£¬ÄÇô¾Í²»ÊÇÖØÈë¡£

Èç¹û¿ÉÒÔÅжϵ±Ç°Ïß³ÌÊÇÖØÈëµÄ£¬ÄÇôÔò¶Ôstate¸ß16½øÐмÓ1²Ù×÷£¬²Ù×÷³É¹¦£¬Ôò¶ÔfirstReader»òcachedHoldCounter½øÐÐÉèÖ㬲¢·µ»Ø1£¬365ÌåÓýͶע»ñÈ¡µ½Ëø¡£

µ½ÕâÀï365betÌåÓýÔÚÏßÃÇ¿´ÍêÁËtryAcquireShared·½·¨£¬365betÌåÓýÔÚÏßÔÙ°ÑacquireShared·½·¨Ìù³öÀ´£º

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

ÏÂÃæ¿´doAcquireShared·½·¨£º

private void doAcquireShared(int arg) {
	  //ʵÀý»¯Ò»¸ö¹²Ïí½ÚµãÈë¶Ó
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
			  //»ñÈ¡µ±Ç°½ÚµãµÄÉÏÒ»¸öÇ°Öýڵã
            final Node p = node.predecessor();
			  //Ç°ÖýڵãÈç¹ûÊÇÍ·½Úµã£¬ÄÇô´ú±í¶ÓÁÐÀïûÓбðµÄ½Úµã£¬Ïȵ÷ÓÃtryAcquireShared³¢ÊÔ»ñÈ¡Ëø
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
					   //ÐѶÓÁÐÖÐÆäËû¹²Ïí½Úµã
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
					   //ÏìÓ¦ÖжÏ
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
			  //ÉèÖÃÇ°ÖýڵãwaitStatus״̬
            if (shouldParkAfterFailedAcquire(p, node) &&
				  //×èÈûµ±Ç°Ïß³Ì
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

doAcquireShared·½·¨ÖлáʵÀý»¯Ò»¸ö¹²Ïí½Úµã²¢Èë¶Ó¡£Èç¹ûµ±Ç°½ÚµãµÄÇ°ÖýڵãÊÇÍ·½Úµã£¬ÄÇôֱ½Óµ÷ÓÃtryAcquireSharedÏÈ»ñÈ¡Ò»´ÎËø£¬Èç¹û·µ»Ø´óÓÚ0£¬ÄÇô365ÌåÓýͶע¿ÉÒÔ»ñÈ¡Ëø£¬µ÷ÓÃsetHeadAndPropagate»½ÐѶÓÁÐÖÐÆäËûµÄỊ̈߳»Èç¹ûûÓзµ»ØÔò»áµ÷ÓÃshouldParkAfterFailedAcquire·½·¨½«Ç°ÖýڵãµÄwaitStatusÉèÖµ³ÉSIGNAL£¬È»ºóµ÷ÓÃparkAndCheckInterrupt·½·¨×èÈû

AQS#setHeadAndPropagate

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
	  //°Ñnode½ÚµãÉèֵΪͷ½Úµã
    setHead(node); 
	  //ÒòΪÊÇpropagate´óÓÚÁã²Å½øÕâ¸ö·½·¨£¬365betÌåÓýÔÚÏßÕâ¸ö±Ø½øÕâ¸öif
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
		  //»ñÈ¡nodeµÄÏÂÒ»¸ö½Úµã
        Node s = node.next;
		  //ÅжÏÏÂÒ»¸ö½ÚµãÊÇ·ñΪ¿Õ£¬»òÊǹ²Ïí½Úµã
        if (s == null || s.isShared())
			  //ÍùÏ¿´
            doReleaseShared();
    }
}

Õâ¸ö·½·¨Ö÷ÒªÊÇÌ滻ͷ½ÚµãΪµ±Ç°½Úµã£¬È»ºóµ÷ÓÃdoReleaseShared½øÐл½ÐѽڵãµÄ²Ù×÷

AQS#doReleaseShared

private void doReleaseShared() { 
    for (;;) {
        Node h = head;
        // 1. h == null: ˵Ã÷×èÈû¶ÓÁÐΪ¿Õ
        // 2. h == tail: ˵Ã÷Í·½áµã¿ÉÄÜÊǸոճõʼ»¯µÄÍ·½Úµã£¬
        //   »òÕßÊÇÆÕͨÏ߳̽ڵ㣬µ«ÊǴ˽ڵã¼ÈÈ»ÊÇÍ·½ÚµãÁË£¬ÄÇô´ú±íÒѾ­±»»½ÐÑÁË£¬×èÈû¶ÓÁÐûÓÐÆäËû½ÚµãÁË
        // 365betÌåÓýÔÚÏßÕâÁ½ÖÖÇé¿ö²»ÐèÒª½øÐл½ÐѺó¼Ì½Úµã
        if (h != null && h != tail) {
            int ws = h.waitStatus;
			   //ºóÃæµÄ½Úµã»á°ÑÇ°ÖýڵãÉèÖÃΪNode.SIGNAL
            if (ws == Node.SIGNAL) {
				  	//1
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
					// »½ÐÑ head µÄºó¼Ì½Úµã£¬Ò²¾ÍÊÇ×èÈû¶ÓÁÐÖеĵÚÒ»¸ö½Úµã
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
						//2
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
		  //3 Èç¹û±»»½ÐѵĽڵãÒѾ­Õ¼ÁìheadÁË£¬ÄÇô¼ÌÐøÑ­»·£¬·ñÔòÌø³öÑ­»·
        if (h == head)                   // loop if head changed
            break;
    }
}

1. unparkSuccessorÕâÀï»á»½ÐÑÏÂÒ»¸ö½Úµã£¬ÄÇôÏÂÒ»¸ö½ÚµãÒ²»áµ÷ÓÃsetHeadAndPropagate½øÐÐÇÀռͷ½Úµã£»Èç¹ûͬʱÓе±Ç°Ï̺߳ͱ»»½ÐѵÄÏÂÒ»¸öÏß³Ìͬʱ×ßµ½ÕâÀÄÇôֻ»áÓÐÒ»¸ö³É¹¦£¬ÁíÒ»¸ö·µ»ØfalseµÄ¾Í²»½øÐл½ÐѲÙ×÷
2. ÕâÀïCASʧ°ÜµÄÔ­Òò¿ÉÄÜÊÇÒ»¸öеĽڵãÈë¶Ó£¬È»ºó½«Ç°ÖýڵãÉèֵΪÁËNode.SIGNAL£¬365betÌåÓýÔÚÏßµ¼Öµ±Ç°µÄCASʧ°Ü
3. Èç¹û±»»½ÐѵĽڵãÇÀռͷ½Úµã³É¹¦£¬ÄÇôh == head ¾Í²»³ÉÁ¢£¬ÄÇô»á½øÐÐÏÂÒ»ÂÖµÄÑ­»·£¬·ñÔò¾ÍÊÇheadûÓб»ÇÀÕ¼³É¹¦

AQS#unparkSuccessor

private void unparkSuccessor(Node node) {
    //Èç¹ûµ±Ç°½ÚµãСÓÚÁ㣬ÄÇô×÷Ϊͷ½ÚµãÒª±»Çå³ýÒ»ÏÂ״̬
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    // ÏÂÃæµÄ´úÂë¾ÍÊÇ»½ÐѺó¼Ì½Úµã£¬µ«ÊÇÓпÉÄܺó¼Ì½ÚµãÈ¡ÏûÁ˵ȴý
    // ´Ó¶ÓβÍùÇ°ÕÒ£¬ÕÒµ½waitStatus<=0µÄËùÓнڵãÖÐÅÅÔÚ×îÇ°ÃæµÄ
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        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);
}

µ½ÕâÀï¼Ó¶ÁËøµÄ´úÂë¾Í½²½âÍê±ÏÁË

¶ÁËøÊÍ·Å

//ReadLock
public void unlock() {
    sync.releaseShared(1);
}
// Sync
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared(); 
        return true;
    }
    return false;
}

365betÌåÓýÔÚÏßÃÇÏÈ¿´tryReleaseShared

Sync#tryReleaseShared

protected final boolean tryReleaseShared(int unused) {
    Thread current = Thread.currentThread();
	  //Èç¹ûµ±Ç°ÊÇfirstReader£¬ÄÇôÐèÒª½øÐÐÖØÖûòÖØÈë¼õÒ»
    if (firstReader == current) {
        // assert firstReaderHoldCount > 0;
        if (firstReaderHoldCount == 1)
            firstReader = null;
        else
            firstReaderHoldCount--;
    } else {
		  // ÅÐ¶Ï cachedHoldCounter ÊÇ·ñ»º´æµÄÊǵ±Ç°Ị̈߳¬²»ÊǵĻ°Òªµ½ ThreadLocal ÖÐÈ¡
        HoldCounter rh = cachedHoldCounter;
        if (rh == null || rh.tid != getThreadId(current))
            rh = readHolds.get();
        int count = rh.count;
        if (count <= 1) {
			   // ÕâÒ»²½½« ThreadLocal remove µô£¬·ÀÖ¹ÄÚ´æй©¡£ÒòΪÒѾ­²»ÔÙ³ÖÓжÁËøÁË
            readHolds.remove();
			   //unlockÁ˼¸´ÎµÄ»°»áÅ×Òì³£
            if (count <= 0)
                throw unmatchedUnlockException();
        }
        --rh.count;
    }
    for (;;) {
        int c = getState();
		   // nextc ÊÇ state ¸ß 16 λ¼õ 1 ºóµÄÖµ
        int nextc = c - SHARED_UNIT;
        if (compareAndSetState(c, nextc))
            // Èç¹û nextc == 0£¬ÄǾÍÊÇ state È«²¿ 32 λ¶¼Îª 0£¬Ò²¾ÍÊǶÁËøºÍдËø¶¼¿ÕÁË
            // ´ËʱÕâÀï·µ»Ø true µÄ»°£¬ÆäʵÊÇ°ïÖú»½ÐѺó¼Ì½ÚµãÖеĻñȡдËøµÄÏß³Ì
            return nextc == 0;
    }
}

Õâ¸ö¶ÁËøµÄÊÍ·Å£¬Ö÷Òª¾ÍÊǽ« hold count ¼õ 1£¬Èç¹û¼õµ½ 0 µÄ»°£¬»¹Òª½« ThreadLocal ÖÐµÄ remove µô¡£È»ºóÊÇÔÚ for Ñ­»·Öн« state µÄ¸ß 16 λ¼õ 1£¬Èç¹û·¢ÏÖ¶ÁËøºÍдËø¶¼ÊͷŹâÁË£¬ÄÇô»½ÐѺó¼ÌµÄ»ñȡдËøµÄỊ̈߳¬ÒòΪֻÓжÁËøÊDz»»á±»×èÈûµÄ£¬365betÌåÓýÔÚÏߵȴýµÄÏß³ÌÖ»¿ÉÄÜÊÇдËøµÄÏ̡߳£

дËøµÄ»ñÈ¡

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

//AQS
protected final boolean tryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState();
	  //»ñÈ¡stateµÄµÍ16λ
    int w = exclusiveCount(c);
	  //²»ÎªÁã˵Ã÷¶ÁËø»òдËø±»³ÖÓÐÁË
    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        // ¿´ÏÂÕâÀï·µ»Ø false µÄÇé¿ö£º
        //   c != 0 && w == 0: дËø¿ÉÓ㬵«ÊÇÓÐÏ̳߳ÖÓжÁËø(Ò²¿ÉÄÜÊÇ×Ô¼º³ÖÓÐ)
        //   c != 0 && w !=0 && current != getExclusiveOwnerThread(): ÆäËûÏ̳߳ÖÓÐдËø
        //   Ò²¾ÍÊÇ˵£¬Ö»ÒªÓжÁËø»òдËø±»Õ¼Óã¬Õâ´Î¾Í²»ÄÜ»ñÈ¡µ½Ð´Ëø
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
		  // ÕâÀï²»ÐèÒª CAS£¬×Ðϸ¿´¾ÍÖªµÀÁË£¬Äܵ½ÕâÀïµÄ£¬Ö»¿ÉÄÜÊÇдËøÖØÈ룬²»È»ÔÚÉÏÃæµÄ if ¾ÍÀ¹½ØÁË
        setState(c + acquires);
        return true;
    }
	  //¼ì²éдËøÊÇ·ñÐèÒªblock
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
	  //×ßµ½ÕâÀï˵Ã÷дËø²»ÐèÒªblock£¬²¢ÇÒCAS³É¹¦ÁË
    setExclusiveOwnerThread(current);
    return true;
}

365betÌåÓýÔÚÏßÃÇÀ´¿´¿´writerShouldBlock

//NonfairSync
final boolean writerShouldBlock() {
    return false; // writers can always barge
}
//FairSync
final boolean writerShouldBlock() {
    return hasQueuedPredecessors();
}

Èç¹ûÊǷǹ«Æ½Ä£Ê½£¬ÄÇô lock µÄʱºò¾Í¿ÉÒÔÖ±½ÓÓà CAS È¥ÇÀËø£¬ÇÀ²»µ½ÔÙÅŶÓ

Èç¹ûÊǹ«Æ½Ä£Ê½£¬ÄÇôÈç¹û×èÈû¶ÓÁÐÓÐÏ̵߳ȴýµÄ»°£¬¾Í¹Ô¹ÔÈ¥ÅŶÓ

дËøÊÍ·Å

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

//sync
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
		  //Èç¹û¶ÀÕ¼ËøÊÍ·Å"ÍêÈ«"£¬»½ÐѺó¼Ì½Úµã
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

//Sync
protected final boolean tryRelease(int releases) {
	  //¼ì²éһϳÖÓÐËùµÄÏß³ÌÊDz»Êǵ±Ç°Ïß³Ì
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
	  //½«state¼õ1
    int nextc = getState() - releases;
    //²é¿´µÍ16λÊÇ·ñΪ0
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
		  //Èç¹ûΪ0£¬ÄÇô˵Ã÷дËøÊÍ·Å
        setExclusiveOwnerThread(null);
	  //ÉèÖÃ״̬
    setState(nextc);
    return free;
}