Java可重入锁reentrantLock解析

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设置成1
if(compareAndSetState(0,1))
//如果设置成功说明当前线程获取了锁，把锁拥有者设置成当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
设置失败则走这个方法
acquire(1);
}
 

public final voidacquire(int arg){
//这里if使用&&执行了两个方法，当两个条件都true时会执行selfInterrupt();，也就是中断当前线程，这里可以猜测一下：这两个方法应该就是获取锁或者进入等待队列，当都失败时说明加锁过程就失败了，直接中断线程结束流程。
if(!tryAcquire(arg)&&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
 

final booleannonfairTryAcquire(int acquires){
//获取当前线程
    final Thread current = Thread.currentThread();
//获取state的值，state是被volatile修饰，对所有线程都可见
int c =getState();
//当state值为0时，说明此时持有锁的线程已经释放锁，此时就可以通过cas重新竞争锁
if(c ==0){
if(compareAndSetState(0, acquires)){
setExclusiveOwnerThread(current);
returntrue;
}
}
//当state值不为0时，判断当前线程是否是锁持有线程，是则把state设置成原值+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) {
//把当前线程封装成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;
//判断当前AQS的tail是否是null，刚开始肯定是null，但当已经有一个node在AQS中时就不为null，不为null时把node设置为tail，pred的next指针指向node，node的prev指针指向pred
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//tail为null时执行
enq(node);
return node;
}
 

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
//当tail为null时使head=tail=new Node()
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
            tail = head;
        } else {
//不为null时把node设置为tail，pred的next指针指向node，node的prev指针指向pred，并跳出死循环
            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 (;;) {
获取当前线程的前一个节点
final Node p = node.predecessor();
//如果前一个是head则会再执行nonfairTryAcquire方法进行获取锁，如果获取成功
if (p == head && tryAcquire(arg)) {
把当前线程的node设置成head，thead=null，prev=null
setHead(node);
把之前的head从双向链表中断开引用，让gc回收
p.next = null; // help GC
failed = false;
return interrupted;
}
//如果前一个节点不是head或者获取锁失败则执行if中的方法
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
 

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//获取当前线程前一个node的waitStatus值，waitStatus是volatile修饰的int，所以初始化值是0
int ws = pred.waitStatus;
//当waitStatus是-1时，说明当前node已经给pred node设置过waitStatus了，直接返回true
if (ws == Node.SIGNAL)
return true;
//当waitStatus大于0时，实际上就是1，1代表CANCELLED，就是已经终止了的node，所以用while直接跳过所有终止的node，并返回false
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//如果即不等于-1也不是1，就把pred设置成-1，-1实际上就是代表当前node需要park，然后返回false
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
 

public final boolean release(int arg) {
//先执行tryRelease方法，tryRelease方法返回true继续执行if逻辑
if (tryRelease(arg)) {
Node h = head;
//head不为null并且waitStatus不为0时会执行unparkSuccessor方法，我们知道waitStatus初始值是0，并且在shouldParkAfterFailedAcquire方法时把waitStatus设置为-1
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
 

protected final boolean tryRelease(int releases) {
//当前state减去releases值获取c
    int c = getState() - releases;
//当前线程不是拥有锁的线程则报错
    if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
    boolean free = false;
//如果为0则说明没有线程持有锁，则把拥有锁的线程设置成null
    if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
    }
//把status设置成c
    setState(c);
//返回是否没有持有锁的线程
    return free;
}
 

private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//先拿到waitStatus，如果小于0，则把他设置成初始值0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
//获取node的下一个node，如果s是null或则waitStatus大于0.则用for循环从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中的线程，此时就会进入acquireQueued方法中的for循环再次尝试获取锁
if (s != null)
LockSupport.unpark(s.thread);
}