可重入锁ReentrantLock详解

AtomicInteger解析：http://donald-draper.iteye.com/blog/2359555
锁持有者管理器AbstractOwnableSynchronizer：http://donald-draper.iteye.com/blog/2360109
AQS线程挂起辅助类LockSupport：http://donald-draper.iteye.com/blog/2360206
AQS详解-CLH队列，线程等待状态：http://donald-draper.iteye.com/blog/2360256
AQS-Condition详解：http://donald-draper.iteye.com/blog/2360381

/*
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
前面的文章中，我们看了CAS原理和AQS机制，今天我们来看已下可重入锁ReentrantLock。
ReentrantLock本质上一种独占锁，获取锁方式有公平与非公平获取锁方式。
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

/**
 * A reentrant mutual exclusion {@link Lock} with the same basic
 * behavior and semantics as the implicit monitor lock accessed using
 * {@code synchronized} methods and statements, but with extended
 * capabilities.
 *
 一个与implicit monitor lock具有相同功能的可扩展的可重入互质锁。

 * <p>A {@code ReentrantLock} is [i]owned[/i] by the thread last
 * successfully locking, but not yet unlocking it. A thread invoking
 * {@code lock} will return, successfully acquiring the lock, when
 * the lock is not owned by another thread. The method will return
 * immediately if the current thread already owns the lock. This can
 * be checked using methods {@link #isHeldByCurrentThread}, and {@link
 * #getHoldCount}.
可重入锁，被上次成功获取锁，还没释放的线程，所拥有的；当锁没有被其他线程所
持有，线程可以调用lock函数，获取锁；当锁的持有者为当前线程，当前线程调用lock函数，
立刻返回，并获取锁；可用isHeldByCurrentThread方法，判断锁是否被当前单线程所持有，
用getHoldCount获取当前线程，持有锁的次数（在线程持有锁，再次调用lock，成功获取锁的次数）。

 *
 * <p>The constructor for this class accepts an optional
 * [i]fairness[/i] parameter.  When set {@code true}, under
 * contention, locks favor granting access to the longest-waiting
 * thread.  Otherwise this lock does not guarantee any particular
 * access order.  Programs using fair locks accessed by many threads
 * may display lower overall throughput (i.e., are slower; often much
 * slower) than those using the default setting, but have smaller
 * variances in times to obtain locks and guarantee lack of
 * starvation. Note however, that fairness of locks does not guarantee
 * fairness of thread scheduling. Thus, one of many threads using a
 * fair lock may obtain it multiple times in succession while other
 * active threads are not progressing and not currently holding the
 * lock.
 * Also note that the untimed {@link #tryLock() tryLock} method does not
 * honor the fairness setting. It will succeed if the lock
 * is available even if other threads are waiting.
 *
ReentrantLock的构造函数有一个公平性参数boolean，来确定，可重入锁是公平锁，还是非公平锁。
如果是公平锁，当锁没有持有者时，将锁授予，最早等待获取锁的线程；非公平锁，不能保证按照
获取锁的顺序，将锁的授予线程；非公平锁在性能上，更优一些，但在获取锁的尝试次数和保证
lack of starvation（锁的饥渴性，暂时这么翻译）上，两种锁没有太多的差别。公平锁，也不能
绝对的保证公平性，比如，当其他的线程等待锁的时候，一个线程持有锁，也许在持有锁的过程中，
多次获取锁。tryLock也不能保证公平性，即使其他的线程在等待锁，一个线程持有锁，调用tryLock
如果锁可利用，则线程获取锁成功。
为什么，非公平锁的性能比公平锁要高呢？假设现在有一些线程在等待锁，当锁被持有者释放时，
这时，正好有一个线程获取锁，非公平锁则获取成功，公平锁则要从锁等待队列线程中，唤醒一个线程
，进入就绪运行状态，切换上下文，倒不如，让正在请求锁的线程，直接获取锁。

 * <p>It is recommended practice to [i]always[/i] immediately
 * follow a call to {@code lock} with a {@code try} block, most
 * typically in a before/after construction such as:
 *
在使用ReentrantLock时候，强烈建议在获取锁后面使用try语句块，以便在
finally中释放锁，如下
 * <pre>
 * class X {
 *   private final ReentrantLock lock = new ReentrantLock();
 *   // ...
 *
 *   public void m() {
 *     lock.lock();  // block until condition holds
 *     try {
 *       // ... method body
 *     } finally {
 *       lock.unlock()
 *     }
 *   }
 * }
 * </pre>
 *
 * <p>In addition to implementing the {@link Lock} interface, this
 * class defines methods {@code isLocked} and
 * {@code getLockQueueLength}, as well as some associated
 * {@code protected} access methods that may be useful for
 * instrumentation and monitoring.
 对于实现可重入锁ReentrantLock，除了Lock中的方法外，还可以调用
 ReentrantLock锁的isLocked和getLockQueueLength方法，和一些protected的
 方法，以便监视锁的状态
 *
 * <p>Serialization of this class behaves in the same way as built-in
 * locks: a deserialized lock is in the unlocked state, regardless of
 * its state when serialized.
 *
 序列化可重入锁ReentrantLock，则忽略锁状态,反序列化时，锁处于unlocked state；

 * <p>This lock supports a maximum of 2147483647 recursive locks by
 * the same thread. Attempts to exceed this limit result in
 * {@link Error} throws from locking methods.
 *一个线程可以持有锁的次数为2147483647(2^31-1),当尝试次数，超过最大限制时，则
 抛出异常，如果线程在持有2147483647次的情况下，再TryAcquire，则锁的持有数为-1；
 超过整数范围溢出；
 * @since 1.5
 * @author Doug Lea
 */
public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    //同步器，提供所有锁机制
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    //可重入锁，依赖于同步Sync，同步是基于AQS的实现；同步Sync
    //有两种实现一种是公平锁，一种是非公平锁；用AQS state表示，锁的状态。
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
	 在非公平锁实现中，允许快速获取锁
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is
         * implemented in subclasses, but both need nonfair
         * try for trylock method.
         */
	 //在非公平锁的尝试获取锁方法中，会调用nonfairTryAcquire
	 //acquires为尝试获取次数，一般为1
        final boolean nonfairTryAcquire(int acquires) {
	   //获取当前线程
            final Thread current = Thread.currentThread();
            int c = getState();//获取锁状态
            if (c == 0) {//如果没有线程持有锁
                if (compareAndSetState(0, acquires)) {
		    //尝试获取锁，如果获取成功，则设置锁的持有者，为当前线程，返回ture
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
	        //如果锁被线程持有，判断持有者是不是当前线程；
		//如果当前线程是锁的持有者，则锁被当前线程持有的次数+获取次数acquires
                int nextc = c + acquires;
                if (nextc < 0) // overflow
		    //如果锁被线程连续持有次数，小于0，则超出，一个线程可以连续持有锁的最大次数
		    //抛出异常
                    throw new Error("Maximum lock count exceeded");
		 //否则，设置锁状态，返回true
                setState(nextc);
                return true;
            }
	    //锁被持有，且持有者非当前线程，返回false，获取锁失败。
            return false;
        }
        //尝试释放锁，releases释放次数
        protected final boolean tryRelease(int releases) {
	    //获取释放releases次锁后的锁状态。
            int c = getState() - releases;
	    //如果当前线程非锁持有者，抛出状态监控异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
	    //如果锁持有者线程释放，releases次后，锁状态为打开
            if (c == 0) {
	        //释放锁成功
                free = true;
		//设置锁持有者为NULL
                setExclusiveOwnerThread(null);
            }
	    //如果，释放releases次后，线程仍持有锁，设置锁状态，释放失败。
            setState(c);
            return free;
        }
        //检查锁持有者是否为当前线程
        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
        //创建条件，这个我们在前面讲过
        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // Methods relayed from outer class
        //获取锁持有者线程，无持有者，则为null
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }
        //获取线程连续持有锁的次数，如果是当前线程持有锁，则返回state，否则为0
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
        //锁是否被持有
        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes this lock instance from a stream.
         * @param s the stream
         */
	//反序列化锁，设置锁为打开状态
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }
     /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    //创建可重入锁，默认为非公平锁
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
     //根据公平锁与非公平锁标志，创建相应的锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
     static final class NonfairSync extends Sync {}
     static final class FairSync extends Sync {}
}

从上面可以看出ReentrantLock关联一个同步锁SYNC，内部的SYNC是基于AQS实现的。
同步锁SYNC有两种实现，公平锁与非公平锁；ReentrantLock默认创建的是非公平锁。
下面再来看一下公平锁与非公平锁，先看非公平锁

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
	   //先以CAS方式获取锁，如果获取成功，设置当前线程为锁，持有者
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
	       //否则，这一步我们单看
                acquire(1);
        }
        //尝试获取锁，acquires次，一般为1
        protected final boolean tryAcquire(int acquires) {
	   //以非公平的方式获取锁
            return nonfairTryAcquire(acquires);
        }
    }

//AQS

/**
     * Acquires in exclusive mode, ignoring interrupts.  Implemented
     * by invoking at least once {@link #tryAcquire},
     * returning on success.  Otherwise the thread is queued, possibly
     * repeatedly blocking and unblocking, invoking {@link
     * #tryAcquire} until success.  This method can be used
     * to implement method {@link Lock#lock}.
     *尝试以独占模式，获取锁，忽略中断。至少尝试一次，获取锁，成功则返回，
     获取失败，添加到同步等待队列，可能重复的blocking and unblocking，
     尝试获取锁，直到成功，用于lock方法
     * @param arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like.
     */
    public final void acquire(int arg) {
        //如果获取锁失败，则添加独占模式节点，到队列中，自旋，队列头部节点尝试获取锁，
	如果尝试获取失败，检查是否可以中断当前线程，如果可以，则中断当前线程。
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
//待父类扩展
 protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

先看

addWaiter(Node.EXCLUSIVE)

再看

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

最后再看

 selfInterrupt();

//添加独占模式等待节点

addWaiter(Node.EXCLUSIVE)

/**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    创建独占或共享模式节点到同步等待队列中
    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;
    }

再看
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

这个方法我们在Condition那篇文章中说过，
首次查看节点的前驱节点线程，是否是头节点，如果时，则尝试获取
锁，如果成功，则设置节点为头节点；否则检查当是否应该再获取锁的时候
，唤醒后继节点；如果尝试获取锁失败，则park当前线程，如果失败，则整个
过程失败，从队列中移除当前线程节点。

 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);
        }
    }

自旋请求锁，如果可能的话挂起线程，直到得到锁，返回当前线程是否中断过
（如果park()过并且中断过的话有一个interrupted中断位）。
。acquireQueued过程是这样的：
1. 如果当前节点是AQS队列的头结点（如果第一个节点是DUMP节点也就是傀儡节点，
那么第二个节点实际上就是头结点了），就尝试在此获取锁tryAcquire(arg)。
如果成功就将头结点设置为当前节点（不管第一个结点是否是DUMP节点），返回中断位。否则进行2。
2. 检测当前节点是否应该park()，如果应该park()就挂起当前线程并且返回当前线程中断位。进行操作1。
最后再看

selfInterrupt();
    /**
     * Convenience method to interrupt current thread.
     */
    private static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

再看公平锁

/**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
	   //这个过程，前面说过//如果获取锁失败，则添加独占模式节点，
	   到队列中，自旋，队列头部节点尝试获取锁，
	如果尝试获取失败，检查是否可以中断当前线程，如果可以，则中断当前线程。
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
	 这个函数与SYNC的nonfairTryAcquire方法基本相同
        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;
        }
    }

我们再回到SYNC的nonfairTryAcquire方法，非公平尝试获取锁；
//SYNC
      

 /**
         * Performs non-fair tryLock.  tryAcquire is
         * implemented in subclasses, but both need nonfair
         * try for trylock method.
         */
	 //在非公平锁的尝试获取锁方法中，会调用nonfairTryAcquire
	 //acquires为尝试获取次数，一般为1
        final boolean nonfairTryAcquire(int acquires) {
	   //获取当前线程
            final Thread current = Thread.currentThread();
            int c = getState();//获取锁状态
            if (c == 0) {//如果没有线程持有锁
                if (compareAndSetState(0, acquires)) {
		    //尝试获取锁，如果获取成功，则设置锁的持有者，为当前线程，返回ture
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
	        //如果锁被线程持有，判断持有者是不是当前线程；
		//如果当前线程是锁的持有者，则锁被当前线程持有的次数+获取次数acquires
                int nextc = c + acquires;
                if (nextc < 0) // overflow
		    //如果锁被线程连续持有次数，小于0，则超出，一个线程可以连续持有锁的最大次数
		    //抛出异常
                    throw new Error("Maximum lock count exceeded");
		 //否则，设置锁状态，返回true
                setState(nextc);
                return true;
            }
	    //锁被持有，且持有者非当前线程，返回false，获取锁失败。
            return false;
        }

比较非公平锁的尝试获取锁nonfairTryAcquire与公平锁TryAcquire的区别在与
非公平尝试获取锁时，如果锁为打开状态，则锁住锁；而公平锁，则先看有没有前驱节点
，有前驱，则不能锁住锁，没有则可锁住。

我们再对比一下公平锁和非公平锁的lock方法

 

 static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
	   //这个过程，前面说过
	   //如果获取锁失败，则添加独占模式节点，
	   到队列中，自旋，队列头部节点尝试获取锁，如果获取成功，设置当前节点为头节点；
	如果尝试获取失败，检查是否可以中断当前线程，如果可以，则中断当前线程。
            acquire(1);
        }
}
  static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
	   //先以CAS方式获取锁，如果获取成功，设置当前线程为锁，持有者
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

从上面可以看出，非公平锁与公平锁lock的时候，最大的不同是非公平锁，
先以CAS的方式锁住锁，在进行acquire操作，而公平锁，直接acquire操作。

再来看可重入锁的其他方法
//ReentrantLock
 

/**
     * Acquires the lock.
     *
     * <p>Acquires the lock if it is not held by another thread and returns
     * immediately, setting the lock hold count to one.
     * 如果锁没有被其他线程锁持有，则立即返回，锁持有锁为1
     * <p>If the current thread already holds the lock then the hold
     * count is incremented by one and the method returns immediately.
     *如果当前线程已经持有锁，则所持有锁自增1
     * <p>If the lock is held by another thread then the
     * current thread becomes disabled for thread scheduling
     * purposes and lies dormant until the lock has been acquired,
     * at which time the lock hold count is set to one.
     */
     如果锁被其他线程所持有，则当前线程自旋，知道获取锁
 public void lock() {
        //委托给同步器
        sync.lock();
    }
     /**
     * Acquires the lock only if it is not held by another thread at the time
     * of invocation.
     * 如果锁没有被其他线程所持有，则获取锁成功
     * <p>Acquires the lock if it is not held by another thread and
     * returns immediately with the value {@code true}, setting the
     * lock hold count to one. Even when this lock has been set to use a
     * fair ordering policy, a call to {@code tryLock()} [i]will[/i]
     * immediately acquire the lock if it is available, whether or not
     * other threads are currently waiting for the lock.
     * This "barging" behavior can be useful in certain
     * circumstances, even though it breaks fairness. If you want to honor
     * the fairness setting for this lock, then use
     * {@link #tryLock(long, TimeUnit) tryLock(0, TimeUnit.SECONDS) }
     * which is almost equivalent (it also detects interruption).
     *如果锁没有被其他线程持有，则获取锁成功，立即返回true，锁持有数设为1.
     当我们获取锁的策略为公平策略时，尝试获取锁时，如果锁可用，则获取成功，
     无论其他线程和当前线程是否在等待锁。如果必须要保持公平可以用tryLock(long, TimeUnit)
     方法。
     * <p> If the current thread already holds this lock then the hold
     * count is incremented by one and the method returns {@code true}.
     *
     * <p>If the lock is held by another thread then this method will return
     * immediately with the value {@code false}.
     *
     * @return {@code true} if the lock was free and was acquired by the
     *         current thread, or the lock was already held by the current
     *         thread; and {@code false} otherwise
     */
//以非公平方式尝试获取锁
     public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

//以公平方式获取锁，其实公平方式，也不一定能保证绝对的公平，前面讲AQS说过
public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

/**
     * Acquires the lock unless the current thread is
     * {@linkplain Thread#interrupt interrupted}.
     *以可中断方式获取锁，当线程获取锁失败，则中断，当线程中断状态被消除时，
     可以尝试获取锁。
     * <p>Acquires the lock if it is not held by another thread and returns
     * immediately, setting the lock hold count to one.
     * 如果锁没有被其他线程锁持有，则立即返回，锁持有锁为1
     * <p>If the current thread already holds this lock then the hold count
     * is incremented by one and the method returns immediately.
     *如果当前线程已经持有锁，则所持有锁自增1
     * <p>If the lock is held by another thread then the
     * current thread becomes disabled for thread scheduling
     * purposes and lies dormant until one of two things happens:
     *
     * [list]
     当锁被其他线程持有，则自旋，尝试获取锁，直到以下两种条件发生
     *
     * <li>The lock is acquired by the current thread; or
     *  锁被当前线程获取
     * <li>Some other thread {@linkplain Thread#interrupt interrupts} the
     * current thread.
     * 其他线程中断当前线程
     * [/list]
     *
     * <p>If the lock is acquired by the current thread then the lock hold
     * count is set to one.
     *
     * <p>If the current thread:
     *
     * [list]
     *
     * <li>has its interrupted status set on entry to this method; or
     *
     * <li>is {@linkplain Thread#interrupt interrupted} while acquiring
     * the lock,
     *
     * [/list]
     *
     * then {@link InterruptedException} is thrown and the current thread's
     * interrupted status is cleared.
     *
     * <p>In this implementation, as this method is an explicit
     * interruption point, preference is given to responding to the
     * interrupt over normal or reentrant acquisition of the lock.
     *
     * @throws InterruptedException if the current thread is interrupted
     */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

//AQS

/**
     * Acquires in exclusive mode, aborting if interrupted.
     * Implemented by first checking interrupt status, then invoking
     * at least once {@link #tryAcquire}, returning on
     * success.  Otherwise the thread is queued, possibly repeatedly
     * blocking and unblocking, invoking {@link #tryAcquire}
     * until success or the thread is interrupted.  This method can be
     * used to implement method {@link Lock#lockInterruptibly}.
     *
      以独占模式获取锁，如线程被中断，则aborting。
     * @param arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like.
     * @throws InterruptedException if the current thread is interrupted
     */
    public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
	   //检查线程是否处于中断状态，是，则抛出中断异常
            throw new InterruptedException();
        if (!tryAcquire(arg))
	    //如果尝试获取锁，失败，则
            doAcquireInterruptibly(arg);
    }
    /**
     * Acquires in exclusive interruptible mode.
     * @param arg the acquire argument
     */
    private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
	//添加独占模式节点，到同步等待队列
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
	        //以自旋方式，这个过程与acquireQueued相似
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
	       //如果失败，移除取消等待的线程节点。
                cancelAcquire(node);
        }
    }

自旋请求锁，如果可能的话挂起线程，直到得到锁；在这一过程中，如果获取失败，且可park当前线程，则park当前线程，再判断是否可以中断，可以则抛出中断异常。


总结：
可重入自旋锁，当线程持有锁，可以多次获取锁，但最多只有2^31-1次；获取失败时，添加到同步等待队列自旋，直到获取锁成功；ReentrantLock关联一个同步锁SYNC，内部的SYNC是基于AQS实现的。同步锁SYNC有两种实现，公平锁与非公平锁；ReentrantLock默认创建的是非公平锁。比较非公平锁的尝试获取锁nonfairTryAcquire与公平锁TryAcquire的区别在于，非公平尝试获取锁时，如果锁为打开状态，则锁住锁；而公平锁，则先看有没有前驱节点，有前驱，则不能锁住锁，没有则可锁住。公平锁与公平锁lock，最大的不同是非公平锁，先以CAS的方式锁住锁，在进行acquire操作，而公平锁，直接acquire操作。
acquire操作主要过程为，自旋，检查节点的前驱节点是否为头节点，如果是，当前节点为同步队列的第一个节点，则尝试获取锁，如果成功，设置头结点为当前节点，否则判断尝试获取锁失败，是否应该park，如果需要park，则park当前线程，park后，检查是否可中断当前线程，如果可，则中断当前线程。

附：