1 // 创建一个 ReentrantLock ，默认是“非公平锁”。
 2 ReentrantLock()
 3 // 创建策略是fair的 ReentrantLock。fair为true表示是公平锁，fair为false表示是非公平锁。
 4 ReentrantLock(boolean fair)
 5 // 查询当前线程保持此锁的次数。
 6 int getHoldCount()
 7 // 返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null。
 8 protected Thread getOwner()
 9 // 返回一个 collection，它包含可能正等待获取此锁的线程。
10 protected Collection<Thread> getQueuedThreads()
11 // 返回正等待获取此锁的线程估计数。
12 int getQueueLength()
13 // 返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。
14 protected Collection<Thread> getWaitingThreads(Condition condition)
15 // 返回等待与此锁相关的给定条件的线程估计数。
16 int getWaitQueueLength(Condition condition)
17 // 查询给定线程是否正在等待获取此锁。
18 boolean hasQueuedThread(Thread thread)
19 // 查询是否有些线程正在等待获取此锁。
20 boolean hasQueuedThreads()
21 // 查询是否有些线程正在等待与此锁有关的给定条件。
22 boolean hasWaiters(Condition condition)
23 // 如果是“公平锁”返回true，否则返回false。
24 boolean isFair()
25 // 查询当前线程是否保持此锁。
26 boolean isHeldByCurrentThread()
27 // 查询此锁是否由任意线程保持。
28 boolean isLocked()
29 // 获取锁。
30 void lock()
31 // 如果当前线程未被中断，则获取锁。
32 void lockInterruptibly()
33 // 返回用来与此 Lock 实例一起使用的 Condition 实例。
34 Condition newCondition()
35 // 仅在调用时锁未被另一个线程保持的情况下，才获取该锁。
36 boolean tryLock()
37 // 如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。
38 boolean tryLock(long timeout, TimeUnit unit)
39 // 试图释放此锁。
40 void unlock()

ReentrantLock函数列表

    public void lock() {//调用FairSync的lock方法
        sync.lock();}//继承Sync   Sync继承AbstractQueuedSynchronizer类static final class FairSync extends Sync {private static final long serialVersionUID = -3000897897090466540L;final void lock() {//调用AbstractQueuedSynchronizer的acquire方法acquire(1);}/*** Fair version of tryAcquire.  Don't grant access unless* recursive call or no waiters or is first.*/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;}}

lock

    public final void acquire(int arg) {//tryAcquire尝试获取锁 //addWaiter(Node.EXCLUSIVE), arg)如果失败新增等待节点//acquireQueued根据队列获取锁if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

aqs实现的acquire()

/*** Fair version of tryAcquire.  Don't grant access unless* recursive call or no waiters or is first.*/

protected final boolean tryAcquire(int acquires) {

    // 获取“当前线程”final Thread current = Thread.currentThread();// 获取“独占锁”的状态int c = getState();// c=0意味着“锁没有被任何线程锁拥有”，if (c == 0) {// 若“锁没有被任何线程锁拥有”，// 则判断“当前线程”是不是CLH队列中的第一个线程线程，// 若是的话，则获取该锁，设置锁的状态，并切设置锁的拥有者为“当前线程”。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;
}

public final boolean hasQueuedPredecessors() {Node t = tail; Node h = head;Node s;return h != t &&((s = h.next) == null || s.thread != Thread.currentThread());
}

private transient volatile Node head;    // CLH队列的队首
private transient volatile Node tail;    // CLH队列的队尾// CLH队列的节点
static final class Node {static final Node SHARED = new Node();static final Node EXCLUSIVE = null;// 线程已被取消，对应的waitStatus的值static final int CANCELLED =  1;// “当前线程的后继线程需要被unpark(唤醒)”，对应的waitStatus的值。// 一般发生情况是：当前线程的后继线程处于阻塞状态，而当前线程被release或cancel掉，因此需要唤醒当前线程的后继线程。static final int SIGNAL    = -1;// 线程(处在Condition休眠状态)在等待Condition唤醒，对应的waitStatus的值static final int CONDITION = -2;// (共享锁)其它线程获取到“共享锁”，对应的waitStatus的值static final int PROPAGATE = -3;　　　

// waitStatus为“CANCELLED, SIGNAL, CONDITION, PROPAGATE”时分别表示不同状态，// 若waitStatus=0，则意味着当前线程不属于上面的任何一种状态。volatile int waitStatus;// 前一节点volatile Node prev;// 后一节点volatile Node next;// 节点所对应的线程volatile Thread thread;// nextWaiter是“区别当前CLH队列是 ‘独占锁’队列 还是 ‘共享锁’队列 的标记”// 若nextWaiter=SHARED，则CLH队列是“独占锁”队列；// 若nextWaiter=EXCLUSIVE，(即nextWaiter=null)，则CLH队列是“共享锁”队列。
    Node nextWaiter;// “共享锁”则返回true，“独占锁”则返回false。final boolean isShared() {return nextWaiter == SHARED;}// 返回前一节点final Node predecessor() throws NullPointerException {Node p = prev;if (p == null)throw new NullPointerException();elsereturn p;}Node() {    // Used to establish initial head or SHARED marker
    }// 构造函数。thread是节点所对应的线程，mode是用来表示thread的锁是“独占锁”还是“共享锁”。Node(Thread thread, Node mode) {     // Used by addWaiterthis.nextWaiter = mode;this.thread = thread;}// 构造函数。thread是节点所对应的线程，waitStatus是线程的等待状态。Node(Thread thread, int waitStatus) { // Used by Conditionthis.waitStatus = waitStatus;this.thread = thread;}
}

private Node addWaiter(Node mode) {// 新建一个Node节点，节点对应的线程是“当前线程”，“当前线程”的锁的模型是mode。Node node = new Node(Thread.currentThread(), mode);Node pred = tail;// 若CLH队列不为空，则将“当前线程”添加到CLH队列末尾if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}// 若CLH队列为空，则调用enq()新建CLH队列，然后再将“当前线程”添加到CLH队列中。
    enq(node);return node;
}

final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {// interrupted表示在CLH队列的调度中，// “当前线程”在休眠时，有没有被中断过。boolean interrupted = false;for (;;) {// 获取上一个节点。// node是“当前线程”对应的节点，这里就意味着“获取上一个等待锁的线程”。final Node p = node.predecessor();if (p == head && tryAcquire(arg)) {setHead(node);p.next = null; // help GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}

// 返回“当前线程是否应该阻塞”
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {// 前继节点的状态int ws = pred.waitStatus;// 如果前继节点是SIGNAL状态，则意味这当前线程需要被unpark唤醒。此时，返回true。if (ws == Node.SIGNAL)return true;// 如果前继节点是“取消”状态，则设置 “当前节点”的 “当前前继节点”  为  “‘原前继节点’的前继节点”。if (ws > 0) {do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {// 如果前继节点为“0”或者“共享锁”状态，则设置前继节点为SIGNAL状态。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;
}

private static void selfInterrupt() {Thread.currentThread().interrupt();
}

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

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

protected final boolean tryRelease(int releases) {// c是本次释放锁之后的状态int c = getState() - releases;// 如果“当前线程”不是“锁的持有者”，则抛出异常！if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;// 如果“锁”已经被当前线程彻底释放，则设置“锁”的持有者为null，即锁是可获取状态。if (c == 0) {free = true;setExclusiveOwnerThread(null);}// 设置当前线程的锁的状态。
    setState(c);return free;
}

private void unparkSuccessor(Node node) {// 获取当前线程的状态int ws = node.waitStatus;// 如果状态<0，则设置状态=0if (ws < 0)compareAndSetWaitStatus(node, ws, 0);//获取当前节点的“有效的后继节点”，无效的话，则通过for循环进行获取。// 这里的有效，是指“后继节点对应的线程状态<=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);
}