ReentrantReadWriteLock实现原理

ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
       readLock.lock();
           sync.acquireShared(1);
               1.tryAcquireShared(arg)
                   1.如果写锁被其他线程持有,获取锁失败,
                   2.如果读锁不需要阻塞并且读锁的个数在最大值允许范围内,则尝试cas获取锁,
                   2.1 获取读锁成功,如果读锁次数为1,则将firstReader属性设置成前线程并设置firstReaderHolderCount为1
                   2.2 如果读锁次数r大于0并且当前线程等于firstReader则更新firstReaderHolderCount值加1
                   2.3 否则增加总的缓存的读锁次数
                   2.4操作完成返回1
                   3.2步骤没成功则执行fullTryAcquireShared().这个方法是TryAcquireShared()的完全版本,就是先尝试性能优化版的方式获取读锁,如果失败在执行完全版本的读锁获取方式
                   4.获取锁失败则执行下一步骤doAcquireShared(arg)
               2.doAcquireShared(arg);
                   1.addWaiter(Node.SHARED);
                       1.将当前线程封装成Node
                       2.如果tail和head未初始化,则初始化,并且都指向node
                       3.如果tail不为null,则将node插入到同步队列尾部
                   2.进入自旋.
                   3.检查当前节点的前置节点是否是head,
                       1.如果是则尝试tryAcquireShared(arg);方法见上.
                       2.如果获取锁成功则执行setHeadAndPropagate()
                       3.setHeadAndPropagate(node, r);
                           1.将当前节点设置为head节点,由于是重入锁(内部是共享锁)所以需要检查判断是否需要接续后续等待线程获取同步锁
                           2.如果propagate属性>0或者后续线程在共享锁模式中等待,则执行doReleaseShared();
                           3.doReleaseShared();
                               1.共享锁模式下的释放操作
                               2.在head不为null并且head不等于tail的情况下,如果head的waitstatus是Signal(后续节点等待激活状态).则cas设置head的状态为0并且unpark head节点的next节点
                               3.如果waitstatus为0(初始化状态),则将head的状态设置为PROPAGATE(代表共享等待模式,下一次获取共享锁无条件传播)
                               4.unpark后续节点线程
                       4.将原head节点的next指针设置为null(帮助gc 回收)
                       5.如果interrupted为true则触发selfInterrupt();
                       6.将failed设置为false
                       7.返回;
                   4.执行shouldParkAfterFailedAcquire(p, node)
                       1.如果状态已经是SIGNAL则直接返回
                       2.检查并在同步链中去掉已经CANCELLED的节点
                       3.将节点设置为SIGNAL状态等待被激活
                   5.上一步返回true则执行parkAndCheckInterrupt()
                       1.park当前线程
                       2.返回线程的interrupted状态
                   6.如果第五步返回true则将interrupted设置为true
                   7.在finally块中将failed等于true的节点执行 cancelAcquire(node);.这里唯一可能执行的情况是上面的selfInterrupt()触发的情况;
                       1.node=null直接返回不做处理
                       2.node的thread属性设置为null
                       3.检测node的pre节点并且移除出于CANCELLED状态的节点,
                       4.将node节点的状态设置为CANCELLED状态
                       5.如果node是tail节点.则cas更新tail为pre节点,并将pred 的next节点设置为null(因为是tail了不能有next节点)
                       6.如果不是tail节点也不是head节点,则cas移除同步链中的node节点
                       7.如果是head则执行unparkSuccessor(node),
                       8.将node.next设置为自己,帮助gc回收
       readLock.unlock();
            sync.releaseShared(1);
               1.先执行tryReleaseShared(arg)
                   1.如果firstReader属性等于当前线程
                       1.如果firstReaderHoldCount==1,则如果firstReader设置为null,因为等于1在释放一次锁之后就不在占有锁了
                       2.否则执行firstReaderHoldCount--;
                   2.firstReader不等于当前线程
                       1.拿到cachedHoldCounter值,这是将threadLocal变量以线程id为key的缓存值
                       2.如果cachedHoldCounter为空,或者cachedHoldCounter不是当前线程的值,则重新通过readHolds.get()获取.
                       3.拿到HoldCounter中的count值,
                           1.如果小于1则移除readHolds中当前现成的值
                           2.如果count小于0,抛出异常.
                       4.执行--count操作
                   3.进入自旋
                       1.拿到锁状态属性state
                       2.计算锁的新值,并使用cas更新
                       3.返回新值==0  代表是否已经释放锁
               2.如果第一步返回true则执行doReleaseShared()(说明见上);并返回TRUE
               3.返回false
ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
       writeLock.lock()
            sync.acquire(1);
               1.执行tryAcquire(arg)
                   1.获取state锁状态属性
                   2.根据state计算出写锁的值(读锁和写锁 使用的是同一个字段state(利用分段高位低位存储不同的标识实现的)
                   3.如果state不为0
                       1.如果写锁为0(则读锁肯定不为0).或者当前拥有写锁的线程不是当前线程则返回false
                       2.如果写锁超过最大值,则抛出异常
                       3.使用setState更新最新的状态值(因为上面的判断,能走到这一步代表是当前线程重复获取读锁所以不需要使用cas
                       4.返回true
                   4.执行writerShouldBlock()判断是否需要挂起写线程,
                       1.如果是公平锁则通过hasQueuedPredecessors判断是否有前置等待的同步队列
                       2.如果是非公平锁则直接返回false,代表可以强占锁
                   5.如果上一步返回true,则尝试cas设置最新的锁状态,失败则返回false
                   6.获得锁成功,则执行setExclusiveOwnerThread(current);,将当前线程设置为独占锁的拥有线程
                   7.返回true
               2.如果获取锁失败则执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                   1.执行addWaiter(Node.EXCLUSIVE)方法,加入同步链
                   2.failed属性默认true
                   3.interrupted属性默认false;
                   4.进入自旋
                       1.如果当前节点的前置节点是head,则执行tryAcquire(arg)尝试获取所
                           1.如果成功,将node更新为head,这里不需要同步,因为只有一个线程可以获得锁
                           2.原head节点的next设置null
                           3.failed设置为false
                           4.返回interrupted属性.这里是false;
                       2.上一步尝试获取锁失败,则执行shouldParkAfterFailedAcquire判断是否需要挂起
                       3.如果需要挂起则执行parkAndCheckInterrupt()
                       4.再次被唤醒时如果parkAndCheckInterrupt()返回为true则将interrupted设置为true
                       5.继续下一轮自旋
                   5.在finally块中将failed等于true的节点执行 cancelAcquire(node);
       writeLock.unlock()
            sync.release(1);
               1.执行tryRelease(arg)
                   1.通过isHeldExclusively判断如果当前线程不是拥有独占所的线程则抛出异常
                       1.return getExclusiveOwnerThread() == Thread.currentThread();
                   2.计算nextc锁释放后的新值(因为是重入锁)
                   3.通过判断free = exclusiveCount(nextc) == 0来判断当前锁是否已经释放
                   4.如果已经彻底释放(free为true)则通过setExclusiveOwnerThread将独占锁拥有线程设置为null
                   5.更新state值为nextc
                   6.返回free
               2.如果完全释放锁,则通过unparkSuccessor唤醒后继节点线程并返回true.如果是重入锁直接返回了.不需要唤醒后继线程
               3.返回false,表示只是减少了的锁的数量,没有释放锁