一、锁的获取
先看下ReentrantLock的lock()方法，整个方法只有一行，调用acquire方法，看看acquire方法的实现：
public final void acquire(intarg) {
if(!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} 这段代码的实现也是比较简洁，先尝试一次tryAcquire操作，如果失败，则把当前线程加入到同步队列中去，这个时候可能会反复的阻塞与唤醒这个线程，直到后续的tryAcquire（看acquireQueued的实现）操作成功。
再看看tryAcquire的实现：
protectedfinal booleantryAcquire(int acquires) {
finalThread current = Thread.currentThread();
intc = getState();
if(c == 0) {
if(isFirst(current) &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
returntrue;
}
}
elseif (current == getExclusiveOwnerThread()) {
intnextc = c + acquires;
if(nextc < 0)
thrownew Error("Maximum lock count exceeded");
setState(nextc);
returntrue;
}
returnfalse;
}
如果大于0，则判断当前线程是否是排他锁的持有线程，如果是，那么把state值加1（注意state是int类型的，所以state的最大值是就是int的最大值）
如果第一次tryAcquire()操作失败，那么就把当前线程加入到等待队列中去，看addWaiter()方法：
private Node addWaiter(Node mode) {
Node node =new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if(pred != null) {
node.prev = pred;
if(compareAndSetTail(pred, node)) {
pred.next = node;
returnnode;
}
}
enq(node);
returnnode;
}
最后在当前线程被加入到等待队列中去以后，再调用acquireQueued去获取锁，看看acquireQueued的代码：
final boolean acquireQueued(finalNode node, int arg) {
try{
booleaninterrupted = false;
for(;;) {
finalNode p = node.predecessor();
if(p == head && tryAcquire(arg)) {
setHead(node);
p.next =null; // help GC
returninterrupted;
}
if(shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted =true;
}
}catch (RuntimeException ex) {
cancelAcquire(node);
throwex;
}
}
这段代码中拿到当前线程在同步队列中的前面一个节点，如果这个节点是是头部，那么马上进行一次tryAcquire操作，如果操作成功，那么把当前线程弹出队列，整个操作就此结束。如果这个节点不是头部或者说tryAcquire操作失败的话，那么就判断是不是要将当前线程给阻塞掉（shouldParkAfterFailedAcquire）方法：判断当前线程是否应该被阻塞掉，实际上判断的是当前线程的前一个节点的状态，如果前一个节点的状态小于0（condition或者signal），那么返回true，阻塞当前线程；如果前一个节点的状态大于0（cancelled），则向前遍历，直到找到一个节点状态不大于0的节点，并且将中间的cancelled状态的节点全部踢出队列；如果前一个节点的状态等于0，那么将其状态置为-1（signal），并且返回false，等待下一次循环的时候再阻塞。
整个锁的获取过程就是这样，我们再来总结一下整个过程：acquire()方法会先调用一次tryAcquire方法获取一次锁，如果失败，则把当前线程加入到等待队列中去，然后再调用acquireQueued获取锁，acquireQueued在当前节点不在头部的时候会把当前线程的前一个结点的状态置为SIGNAL，然后阻塞当前线程。当当前线程到了队列的头部的时候，那么获取锁的操作就会成功返回。
二、锁的释放
首先，我们知道在acquireQueued方法中，如果一个线程成功获取到了锁，那么它就应该是整个等待队列的head节点，然后，我们再来看一看unlock()方法，和lock()方法一样，unlock()方法也是只有一行代码，直接调用release()方法，我们看看release()方法的实现：
public final boolean release(intarg) {
if(tryRelease(arg)) {
Node h = head;
if(h != null && h.waitStatus != 0)
unparkSuccessor(h);
returntrue;
}
returnfalse;
}
protectedfinal booleantryRelease(int releases) {
intc = getState() - releases;
if(Thread.currentThread() != getExclusiveOwnerThread())
thrownew IllegalMonitorStateException();
booleanfree = false;
if(c == 0) {
free =true;
setExclusiveOwnerThread(null);
}
setState(c);
returnfree;
}
这段代码首先获取当前AQS的state状态并且将其值减一，如果结果等于0（锁已经被完全释放），那么将排他锁的持有线程置为null。将AQS的state状态置为减一后的结果。
然后再看看唤醒继任节点的代码：
private void unparkSuccessor(Node node) {
compareAndSetWaitStatus(node, Node.SIGNAL,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);
}
这段代码先清除当前节点的waitStatus为0，然后判断下一个节点是不是null或者cancelled的状态，如果是，则从队列的尾部往前开始找，找到一个非cancelled状态的节点，最后唤醒这个节点。
最后，总结一下释放操作的整个过程：其实整个释放过程就做了两件事情，一个是将state值减1，然后就是判断锁是否被完全释放，如果被完全释放，则唤醒继任节点。
三、整体过程描述
看了上面的锁的获取与释放操作以后，整体过程还是比较清晰的，在文章的最后，我们把获取与释放操作串在一起在简单看一下：
- 获取锁的时候将当前线程放入同步队列，并且将前一个节点的状态置为signal状态，然后阻塞
- 当这个节点的前一个节点成功获取到锁，前一个节点就成了整个同步队列的head。
- 当前一个节点释放锁的时候，它就唤醒当前线程的这个节点，然后当前线程的节点就可以成功获取到锁了
- 这个时候它就到整个队列的头部了，然后release操作的时候又可以唤醒下一个。