Java 读写锁 ReadWriteLock 原理与应用场景详解

 public   interface  ReadWriteLock {  /*  *

     * Returns the lock used for reading.

     *

     * @return the lock used for reading.  */  Lock readLock();  /*  *

     * Returns the lock used for writing.

     *

     * @return the lock used for writing.  */  Lock writeLock();

} 

 /*  * 内部提供的读锁  */ 

     private  final ReentrantReadWriteLock.ReadLock readerLock;  /*  * 内部提供的写锁  */ 
     private  final ReentrantReadWriteLock.WriteLock writerLock;  /*  * AQS来实现的同步器  */  final Sync sync;  /*  *

     * Creates a new {@code ReentrantReadWriteLock} with

     * 默认创建非公平的读写锁  */ 
     public  ReentrantReadWriteLock() {  this ( false  );

    }  /*  *

     * Creates a new {@code ReentrantReadWriteLock} with

     * the given fairness policy.

     *

     * @param fair {@code true} if this lock should use a fair ordering policy  */ 
     public  ReentrantReadWriteLock(boolean fair) {

        sync = fair ?  new  FairSync() :  new  NonfairSync();

        readerLock =  new  ReadLock( this  );

        writerLock =  new  WriteLock( this  );

    } 

 abstract   static   class  Sync extends AbstractQueuedSynchronizer {  //  版本序列号 
     private   static  final  long  serialVersionUID =  6317671515068378041L  ;  //  高16位为读锁，低16位为写锁 
     static  final  int  SHARED_SHIFT   =  16  ;  //  读锁单位 
     static  final  int  SHARED_UNIT    = ( 1  << SHARED_SHIFT);  //  读锁最大数量 
     static  final  int  MAX_COUNT      = ( 1  << SHARED_SHIFT) -  1  ;  //  写锁最大数量 
     static  final  int  EXCLUSIVE_MASK = ( 1  << SHARED_SHIFT) -  1  ;  //  本地线程计数器 
     private  transient ThreadLocalHoldCounter readHolds;  //  缓存的计数器 
     private  transient HoldCounter cachedHoldCounter;  //  第一个读线程 
     private  transient Thread firstReader =  null  ;  //  第一个读线程的计数 
     private  transient  int  firstReaderHoldCount;

} 

 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)  //  1.如果同步状态不为0，且写状态为0,则表示当前同步状态被读锁获取  //  2.或者当前拥有写锁的线程不是当前线程 
                 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  ;

        } 

 protected  final  int  tryAcquireShared( int  unused) {  for  (;;) {  int  c = getState();  int  nextc = c + ( 1 << 16  );  if (nextc < c) {  throw   new  Error( "  Maxumum lock count exceeded  "  );

        }  if (exclusiveCount(c)!= 0  && owner != Thread.currentThread())  return  - 1  ;  if  (compareAndSetState(c,nextc))  return   1  ;

    }

}