ReentrantLock实现的源码分析

读过这篇文章http://ifeve.com/introduce-abstractqueuedsynchronizer/之后感觉对ReentrantLock又有了进一步的认识，但是这篇文章偏于理论，于是我便使用了调试的功能进行了进一步的分析认识，在看这篇文章之前建议先认真阅读上面链接的那篇文章。
先给出里面涉及到的类和接口的关系图：

先贴出来调试的 时候的代码：

public class Run {
    public static void main(String[] args) {
        final Service s = new Service();

        new Thread(new Runnable() {

            public void run() {
                s.methodA();
            }
        },"线程A").start();

        try {
            Thread.sleep(2000);  //这里是为了确保线程A沉睡后线程B才开始执行
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


        new Thread(new Runnable() {

            public void run() {
                s.methodB();
            }
        },"线程B").start();

    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Service {
    private ReentrantLock lock = new ReentrantLock(true);//这里研究的是公平锁
    private Condition con = lock.newCondition();
    private volatile int i = 0;
    public  void methodA(){
        lock.lock();  //step1
            try {
                lock.lock();//重入锁    step2
                try {
                    System.out.println("1");
                    Thread.sleep(100000);//step3 沉睡100秒是为了让我们有足够的时间在调试B线程的methodB的时候不会释放锁     
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                lock.unlock();  //step5
            } finally{
                lock.unlock();  //step6

            }
    }


    public  void methodB(){
        lock.lock();//step4  step7  
        try {
            System.out.println("2");  //step8
        }finally{
            lock.unlock();   //step9
        }


    }
}

当线程A到达step1的时候，其执行的关键代码：

static final class FairSync extends Sync {
....
final void lock() {
            acquire(1);//执行的是Sync的父类AbstractQueuedSynchronizer（后面简称AQS）的方法
        }
protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//step1会进入这里的逻辑，‘获取锁’这三个字的意思我认为就是是否更改了
            //state，若更改了就获取到了，若没有更改则没有获取到
                //hasQueuedPredecessors()判断队列中除了头结点是否还有其他前驱节点，有则返回true
                //if的逻辑  1.当前队列中没有其他线程是当前线程的前驱，2更改state的值为1,
                //3设置当前Lock独占线程的属性为当前线程
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {//step2会进入这里的逻辑，重入锁
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;//step4会返回false，没有获取到锁
        }
    }
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
...
public final void acquire(int arg) {
        //这里的tryAcquire调用的是FairSync重写的方法
        //尝试获取锁，若获取不到，则包装当前线程加入当前队列尾部，并且再次尝试获取锁
        if (!tryAcquire(arg) &&  
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

}

 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;
                return node;
            }
        }
        //这里表示的是当前队列为空或者队列不为空，但是将节点加入尾部的时候失败会走到这里
        enq(node);
        return node;
    }
private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize  //若队列为空则new一个头结点并且将tail指向头结点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {//若队列不为空，则将节点加入队列尾部
                    t.next = node;
                    return t;
                }
            }
        }
    }
....

当执行完step1的时候，lock的内部的各个属性变化：
state:0->1
exclusiveOwnerThread:null->线程A,其他属性均为初始值。
当执行完step2的时候，lock的内部的各个属性变化：
state:1->2 其他属性均不变。//表示重入锁

当执行到step3的时候线程A沉睡，此时线程B开始执行。
接着会执行step4,执行完step4的时候，lock的内部的属性值：
state:2.
head :new Node[next=tail，thread=null];
tail:new Node(thread=线程B,prev=head);
现在来仔细看看step4发生了什么

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

step4执行的时候tryAcquire返回false,表示没有获取到锁
addWaiter(Node.EXCLUSIVE)会在队列中生成两个节点，并设置成头结点和尾节点，返回尾节点,再看acquireQueued发生了什么

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {//若当尾节点的前驱节点为头结点并且获取到锁了
                //则将当前节点设置为头结点,这里tryAcquire(arg)会返回false,因为此时的state为2并且
                //Lock的（exclusiveOwnerThread）独占线程为线程A,当前线程为线程B
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                  //step4第一次循环进入shouldParkAfterFailedAcquire时会将尾节点的前驱节
                  //的waitStatus属性更新值为-1并且返回false，第二次循环进入到
                  //shouldParkAfterFailedAcquire的时候直接返回true接下来会进入
                  //parkAndCheckInterrupt
                  if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//使得当前线程阻塞，此时线程B就会一直在这里阻塞，直到被unpark. 
        //step4执行到这里时记为 线程B状态一，后面当线程B被unpark的时候会继续下面的步骤
        return Thread.interrupted();
    }

分析到这里，也就是step4执行完之后，线程B也就进入阻塞状态了。
此时lock内部的属性状态如下

state:2
head:new Node[waitStatus=-1,next=tail,thread=null,nextWaiter=null] (ps:nextWaiter在条件锁里面会用到,这里没有用到)
tail:new Node[waitStatus=0,pre=head,thread=线程B,nextWaiter=null]
exclusiveOwnerThread:线程A.
其实此时的同步队列中只有两个节点，也就是头结点和尾节点，其内部属性状况如上描述 。

到了线程B状态一后再过一段时间线程A沉睡完了醒来之后，执行到step5
来看看step5执行的关键代码

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

//逻辑：1尝试释放锁（与‘获取锁’一样，要改变state的值，但是与其不同的是若想真正的释放成功，还需要修改
//exclusiveOwnerThread所代表的独占线程，这里仅仅是针对ReentrantLock的内部类Sync，其他类型的锁暂不
//清楚）,2若释放锁成功，获取头结点，当头结点不为空，并且头结点的waitStatus不为0，会进入
//unparkSuccessor,顾名思义，就是解除后继者的阻塞状态，意思就是把头结点的下一个节点包含的线程unpark

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

先来看下tryRelease，这里的参数releases传入的是1，上面分析过当前的state是为2（表示重入锁）的所以在step5也仅仅只是执行了tryRelease，改变了state的值，由2变为1,返回了false,release也返回fasle
但是当执行到step6的时候此时tryRelease返回了true,lock的内部属性state变为0，exclusiveOwnerThread由线程A变成了null.

接着就是执行释放锁之后的操作了。上面分析过当前的头结点的状态了head:new Node[waitStatus=-1,next=tail,thread=null,nextWaiter=null] ，进入unparkSuccessor(h)；

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

紧接着进入unparkSuccessor(Node node)，传入的参数：头结点，做了什么：修改了头结点的waitStatus为0，找到头结点的下一个节点，也就是尾节点，其实也就是线程B所在的那个节点，unpark掉，此时线程B的阻塞状态就被解除了。step6执行完之后。lock的内部属性的状态：
state:0
head:Node[waitStatus=0,next=tail,thread=null,nextWaiter=null]
tail:Node[waitStatus=0,pre=head,thread=线程B,nextWaiter=null]
exclusiveOwnerThread:线程A.

  private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        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);
    }

此时回到线程B阻塞的那个地方继续执行，线程B没有执行过interrupt，因此会返回false.

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//就是这里
        return Thread.interrupted();
    }

回到这个方法（唉！好麻烦）
接着返回false回到acquireQueued的for循环继续运行

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC，这里是为了防止内存泄露，更快的处理废弃的头结点
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

取到尾节点的前驱节点也就是头结点，再次回到tryAcquire这个方法的时候，state为0，hasQueuedPredecessors很显然返回false，接着就将当前的state修改为1，并将lock的属性exclusiveOwnerThread设置为当前线程，也就是线程B.并返回true,此时已经表明线程B‘获取到锁’了，接着看上面的acquireQueued函数，第一个if条件成立，设置线程B所在的节点为头结点，并且返回false.
到此处step7就执行完成了，并且B线程获得了锁。此时lock的内部状态：
state:1
head=tail=Node[waitStatus=0,pre=null,next=null,thread=线程B,nextWaiter=null].
exclusiveOwnerThread:线程B.

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&  
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

step8执行业务，
step9进行释放锁.释放锁的过程上面已经分析过了。

下面是这个过程中的流程图