J.U.C — Locks — ReentrantLock（一）

• 初始化

public ReentrantLock() {sync = new NonfairSync();     // 默认是非公平锁
}public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}

• 公平锁 和 非公平锁 : Lock
  

ReentrantLock lock = new ReentrantLock(true); // 声明公平锁
lock.lock();
try {// method body
} finally {lock.unlock();
}lock.lock() -->// 公平锁: ReentrantLock.FairSyncfinal void lock() {acquire(1);}// 非公平锁: ReentrantLock.NonfairSync(Sync默认)final void lock() {if (compareAndSetState(0, 1))     // 一定程度上不够公平setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}-->// AQSpublic final void acquire(int arg) {if (!tryAcquire(arg) &&     // 1. 如果tryAcquire(arg)成功，那就没有问题拿到锁；若失败则2acquireQueued(addWaiter(Node.EXCLUSIVE), arg))     // 2. 创建一个独占的节点（Node.EXCLUSIVE），并插入CLH队尾；自旋获取锁selfInterrupt();     // 3. 因为在获得锁之前线程会被中断，这个地方会清楚中断标记位}-->公平锁1.protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();     // 获取当前锁的状态if (c == 0) {     // 若为0，说明没有线程持有锁if (!hasQueuedPredecessors() &&     // 若有先序节点，退出；若无则获取锁。 确保公平性，即前面的节点先获取锁compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {     // 若持有锁的线程就是当前线程，则直接state++int nextc = c + acquires;     if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}非公平锁1.final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (compareAndSetState(0, acquires)) {     // 在没有线程持有锁的情况下，直接去获取锁setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}-->2.自旋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)) {     // 如果当前节点是AQS队列的头结点（如果第一个节点是DUMP节点也就是傀儡节点，那么第二个节点实际上就是头结点了），就尝试在此获取锁tryAcquire(arg)。如果成功就将头结点设置为当前节点（不管第一个结点是否是DUMP节点），返回中断位setHead(node);p.next = null; // help GC ？没有把node的prev指针设为null，怎么GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}Node node = new Node(Thread.currentThread(), mode);Node pred = tail;if (pred != null) {     // 若队列不为空，则将当前节点设为tailnode.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 initializeif (compareAndSetHead(new Node()))     // Dump Nodetail = head;} else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}/*** CANCELLED = 1： 节点操作因为超时或者对应的线程被interrupt。节点不应该留在此状态，一旦达到此状态将从CHL队列中踢出。* SIGNAL = -1： 节点的继任节点是（或者将要成为）BLOCKED状态（例如通过LockSupport.park()操作），因此一个节点一旦被释放（解锁）或者取消就需要唤醒（LockSupport.unpack()）它的继任节点。* CONDITION = -2：表明节点对应的线程因为不满足一个条件（Condition）而被阻塞。* 0： 正常状态，新生的非CONDITION节点都是此状态。*/private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;if (ws == Node.SIGNAL)return true;if (ws > 0) {     // 如果前一个节点的等待状态waitStatus>0，也就是前一个节点被CANCELLED了，那么就将前一个节点去掉，递归此操作直到所有前一个节点的waitStatus<=0do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {     //  前一个节点等待状态waitStatus=0，修改前一个节点状态位为SINGAL，表示后面有节点等待你处理compareAndSetWaitStatus(pred, ws, Node.SIGNAL);     // 这个地方没有返回true，即中断，是为了执行下一次循环先尝试获取锁return false;}// 3. static void selfInterrupt() {Thread.currentThread().interrupt();}

公平锁和非公平锁：UnLock

4.       thread-3执行lock：
   

6.     thread-2执行unlock：

7.     thread-3执行unlock: