ReentrantLock-公平锁加锁

volatile AbstractQueuedSynchronizer.state

thread = tn

没有线程处于等待状态

FairSync.tryAcquire(1)

waitStatus = 0

这个方法操作是原子操作，因为是当前线程获得锁如果当前线程不释放锁，其他线程不会走到这儿来

thread = t1

true

通过CAS算法尝试向队列中添加节点

return false

head = nodenode.thread = nullnode.prev = null

false

生成一个队列节点

waitstate = 0

tail == null

thread = null

通过CAS算法设置头节点是否成功

node

pred.waitStatus = -1

return true

此方法为真正的加锁方法CAS算法尝试将state由0变为1

state == 0，表示没有线程拿到锁

当发现state加锁后将变成负数时，抛出异常不用管if (state< 0)                    throw new Error(\"Maximum lock count exceeded\");

lock.lock()

addWaiter(Node.EXCLUSIVE)

pred.waitStatus > 0

这里用的是CAS，我觉得因该没必要

next = null

只有一个线程能够进入到这儿

AbstractQueuedSynchronizer.hasQueuedPredecessors()返回结果是否为false

之所以要这样做，是因为前面的逻辑清除了线程中断标记

interrupted == true

头结点的下一个节点的thread属性是否为当前线程

寻找node之前，waitStatus = 0的节点

FairSync.lock()

AbstractQueuedSynchronizer.compareAndSetState()

公平锁

此时的队列时这样的

addWaiter(Node.EXCLUSIVE)结束返回node节点

enq(node)方法结束

这个步骤为原子操作吗?span style=\"font-size: inherit;\

next = nn

node.prev.next = null

加锁是否成功

AbstractQueuedSynchronizer.exclusiveOwnerThread= currentThread;  加锁成功记录当前持有锁的线程

尝试加锁

returninterrupted 

AbstractQueuedSynchronizer.acquire(1)

prev = null

new ReentrantLock(true)

队列还未初始化head == tail == null

AbstractQueuedSynchronizer.state + 1

prev = n2

AbstractQueuedSynchronizer.setExclusiveOwnerThread(current)

判断是否已有线程处于等待状态

head

prev = head

state == 0

thread = curent

加锁成功结束

表示现在已经有线程持有锁了

LockSupport.park(this)清楚线程是否被中断标记返回线程是否中断

线程是否中断

判断当前尝试加锁的线程是否为持有锁的线程这便是重入锁的实现

这里并没有使用CAS算法，但是依然能够保证原子性因为当前能够访问state属性的只有持有锁的线程。

AbstractOwnableSynchronizer. exclusiveOwnerThread== currentThread

node的前置几点是否为head

interrupted = true

compareAndSetHead(new Node())

waitStatus = 0

next = n1

此时说明，存在锁竞争，有一个或多个线程在抢锁，当前线程抢锁失败

说明head != tail时，head必定不为空

FairSync.tryAcquire(1)返回结果是否为false

tail != head

入队成功

head.next.Thead != currentThread

原先的尾节点的next属性设置为node

pred.waitStatus == -1

enq(node)

当前线程抢锁失败进入等待队列

tail =  head

next = n2

thread = t2

AbstractQueuedSynchronizer.hasQueuedPredecessors()

TcurrentThread().interrupt()

tail

head.next == null

state是否变为1

通过CAS算法设置末节点是否成功

判读AbstractQueuedSynchronizer类中head 、tail两个属性是否相等两个属性都是volatile

此时node是这个状态

结束

new 一个Node节点通过CAS算法设置队列的头节点为新创建的Node

node.prev = tail