package com.example.demo.service;
import lombok.SneakyThrows;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ReenterLockDemo {
	static int flag = 0;
	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		new Thread("線程1") {
			@SneakyThrows
			public void run() {
				while(flag<10) {
					lock.lock();
					try {
						System.out.println(Thread.currentThread().getName()+"打?。?+(++flag));
						condition.signal();
						condition.await();
					}finally {
						lock.unlock();
					}
				}
			};
		}.start();
		new Thread("線程2") {
			@SneakyThrows
			public void run() {
				while(flag<10) {
					lock.lock();
					try {
						System.out.println(Thread.currentThread().getName()+"打?。?+(++flag));
						condition.signal();
						condition.await();
					}finally {
						lock.unlock();
					}
				}
			};
		}.start();
	}
}
 

publicReentrantLock(){
    sync =newNonfairSync();
}

final voidlock(){
//先通過cas把state從0設(shè)置成1
if(compareAndSetState(0,1))
//如果設(shè)置成功說明當(dāng)前線程獲取了鎖，把鎖擁有者設(shè)置成當(dāng)前線程
setExclusiveOwnerThread(Thread.currentThread());
else
設(shè)置失敗則走這個方法
acquire(1);
}
 

public final voidacquire(int arg){
//這里if使用&&執(zhí)行了兩個方法，當(dāng)兩個條件都true時會執(zhí)行selfInterrupt();，也就是中斷當(dāng)前線程，這里可以猜測一下：這兩個方法應(yīng)該就是獲取鎖或者進(jìn)入等待隊(duì)列，當(dāng)都失敗時說明加鎖過程就失敗了，直接中斷線程結(jié)束流程。
if(!tryAcquire(arg)&&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
 

final booleannonfairTryAcquire(int acquires){
//獲取當(dāng)前線程
    final Thread current = Thread.currentThread();
//獲取state的值，state是被volatile修飾，對所有線程都可見
int c =getState();
//當(dāng)state值為0時，說明此時持有鎖的線程已經(jīng)釋放鎖，此時就可以通過cas重新競爭鎖
if(c ==0){
if(compareAndSetState(0, acquires)){
setExclusiveOwnerThread(current);
returntrue;
}
}
//當(dāng)state值不為0時，判斷當(dāng)前線程是否是鎖持有線程，是則把state設(shè)置成原值+acquires,獲取鎖成功
elseif(current ==getExclusiveOwnerThread()){
int nextc = c + acquires;
if(nextc <0)// overflow
thrownewError("Maximum lock count exceeded");
setState(nextc);
returntrue;
}
//否則獲取鎖失敗
returnfalse;
}

private Node addWaiter(Node mode) {
//把當(dāng)前線程封裝成node，nextWaiter=EXCLUSIVE= null
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
//判斷當(dāng)前AQS的tail是否是null，剛開始肯定是null，但當(dāng)已經(jīng)有一個node在AQS中時就不為null，不為null時把node設(shè)置為tail，pred的next指針指向node，node的prev指針指向pred
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//tail為null時執(zhí)行
enq(node);
return node;
}
 

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
//當(dāng)tail為null時使head=tail=new Node()
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
            tail = head;
        } else {
//不為null時把node設(shè)置為tail，pred的next指針指向node，node的prev指針指向pred，并跳出死循環(huán)
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
                }
            }
    }
}

final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
獲取當(dāng)前線程的前一個節(jié)點(diǎn)
final Node p = node.predecessor();
//如果前一個是head則會再執(zhí)行nonfairTryAcquire方法進(jìn)行獲取鎖，如果獲取成功
if (p == head && tryAcquire(arg)) {
把當(dāng)前線程的node設(shè)置成head，thead=null，prev=null
setHead(node);
把之前的head從雙向鏈表中斷開引用，讓gc回收
p.next = null; // help GC
failed = false;
return interrupted;
}
//如果前一個節(jié)點(diǎn)不是head或者獲取鎖失敗則執(zhí)行if中的方法
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
 

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//獲取當(dāng)前線程前一個node的waitStatus值，waitStatus是volatile修飾的int，所以初始化值是0
int ws = pred.waitStatus;
//當(dāng)waitStatus是-1時，說明當(dāng)前node已經(jīng)給pred node設(shè)置過waitStatus了，直接返回true
if (ws == Node.SIGNAL)
return true;
//當(dāng)waitStatus大于0時，實(shí)際上就是1，1代表CANCELLED，就是已經(jīng)終止了的node，所以用while直接跳過所有終止的node，并返回false
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//如果即不等于-1也不是1，就把pred設(shè)置成-1，-1實(shí)際上就是代表當(dāng)前node需要park，然后返回false
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
 

public final boolean release(int arg) {
//先執(zhí)行tryRelease方法，tryRelease方法返回true繼續(xù)執(zhí)行if邏輯
if (tryRelease(arg)) {
Node h = head;
//head不為null并且waitStatus不為0時會執(zhí)行unparkSuccessor方法，我們知道waitStatus初始值是0，并且在shouldParkAfterFailedAcquire方法時把waitStatus設(shè)置為-1
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
 

protected final boolean tryRelease(int releases) {
//當(dāng)前state減去releases值獲取c
    int c = getState() - releases;
//當(dāng)前線程不是擁有鎖的線程則報錯
    if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
    boolean free = false;
//如果為0則說明沒有線程持有鎖，則把擁有鎖的線程設(shè)置成null
    if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
    }
//把status設(shè)置成c
    setState(c);
//返回是否沒有持有鎖的線程
    return free;
}
 

private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//先拿到waitStatus，如果小于0，則把他設(shè)置成初始值0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
//獲取node的下一個node，如果s是null或則waitStatus大于0.則用for循環(huán)從tail往前找waitStatus小于等于0的node，直到找到最前面一個waitStatus小于等于0的node
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;
}
//如果找到了則喚醒node中的線程，此時就會進(jìn)入acquireQueued方法中的for循環(huán)再次嘗試獲取鎖
if (s != null)
LockSupport.unpark(s.thread);
}