ReentranLock及源码解析(学思想，一步一步点进源码)

public class ReentrantLockTest {
 
    public static void main(String[] args) throws InterruptedException {
 
        ReentrantLock lock = new ReentrantLock();
 
        for (int i = 1; i <= 3; i++) {
            lock.lock();
        }
 
        for(int i=1;i<=3;i++){
            try {
 
            } finally {
                lock.unlock();
            }
        }
    }
}

public class ReentrantLockTest { 
	int i=0; 
	ReentrantLock reentrantLock=new ReentrantLock(); 
	public void incr() { 
		reentrantLock.lock(); //加上ReentrantLock
		i+=10; 
		System.out.println(i); 
		reentrantLock.unlock(); //撤掉ReentrantLock，想一下为啥要在代码层面撤掉
	}
	public static void main(String[] args) throws InterruptedException { 
		ReentrantLockTest test=new ReentrantLockTest();
		Thread[] threads=new Thread[5]; 
		for (int j = 0; j < 5; j++) { 
			threads[j] =new Thread(() -> { 
				test.incr(); 
			}); 
			threads[j].start(); 
		}
		for (int j = 0; j < 5; j++) { 
			threads[j].join(); 
		} 
	} 
}

ReentrantLock reentrantLock=new ReentrantLock(); 
	public void incr() { 
		if (reentrantLock.tryLock()) { 
			i += 10; 
			System.out.println(i); 
			reentrantLock.unlock(); 
		} 
	}

public ReentrantLock() { 
	sync = new NonfairSync(); 
}

final void lock( {
	//cas 比较并替换，修改AbstractQueuedsynchronizer类的state字段，用vo1atile修饰，并且jvm底层cas会有锁操作，只能有1个线程能更改成功
	if (compareAndsetstate(0，1))//如果从0改成1 说明能抢占到锁
	//修改Abstractownab1esynchronizer的exclusiveownerThread为当前线程
		setExclusiveownerThread(Thread. currentThread());
	else
		//线程抢占不到的情况执行
		acquire(1);
}

        final void lock() {
        //因为被线程1已经更改为1了， 所以执行失败
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
            //进入acquire
                acquire(1);
        }

    public final void acquire(int arg) {
    //尝试去加锁，看锁是不是释放了，该方法也有2个实现，FairSync与 NonfairSync，我们暂时只看默认的NonfairSync 
    //如果tryAcquire为false，则执行acquireQueued，并且 acquireQueued为true，执行selfInterrupt
        if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

    protected boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }

        final boolean nonfairTryAcquire(int acquires) {
        //获取当前线程，现在我们线程2来抢占锁，并且线程1没有执行完，所以 当前是线程2
            final Thread current = Thread.currentThread();
            //获取AbstractQueuedSynchronizer的值，因为线程1把他设为了 1，所以c为1
            int c = getState();
            //c为0，是线程1释放了锁的场景，但是现在没有，不满足
            if (c == 0) {
            //如果满足，尝试着去抢占锁（把state改成1）
                if (compareAndSetState(0, acquires)) {
                //设置当前执行代码块的线程为线程2
                    setExclusiveOwnerThread(current);
                    //返回ture，代表线程2拿到了锁，去正常执行业务代码
                    return true;
                }
            }
            //如果c!=0.说明有线程在占有锁，那么如果占有的线程跟当前的线程一 致，说明是同一个线程抢占多次锁
            else if (current == getExclusiveOwnerThread()) {
            //将state 改成state +1 这个时候，state不止是一个状态，而 是代表加锁了多少次（重入次数）
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            //如果抢占不到锁，并且当前线程不是占有锁线程，返回false
            return false;
        }

//参数mode 为null(在lock没有用处 condition中有用)
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        //new node对象，对象为AQS中的一个数据结构，里面存有线程信息，以及前 后节点数据、首尾节点等信息
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;//tail node里面定义尾结点，默认为null 
        //所以，thread2进来的时候，pred为null，不满足下面条件
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //进入enq方法
        enq(node);
        //返回node节点
        return node;
    }

//传入的是new的那个node
    private Node enq(final Node node) {
    //自旋
        for (;;) {
        //tail默认为null
            Node t = tail;
            //第一次满足条件
            if (t == null) { // Must initialize
            //cas去设置head节点
                if (compareAndSetHead(new Node()))
                //设置成功，将tail设置为head节点，继续自旋
                    tail = head;
            } else {
            //第二次自旋，当t！=null时进入
            //node的前节点指向t
                node.prev = t;
                //cas将tail节点设置为node
                if (compareAndSetTail(t, node)) {
                //设置t的next为node
                    t.next = node;
                    //跳出循环，返回t
                    return t;
                }
            }
        }
    }

    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        //new一个thread3的node
        // Try the fast path of enq; backup to full enq on failure
        //tail现在指向的是thread2，所以pred为thread2的node
        Node pred = tail;
        //不为null，满足条件
        if (pred != null) {
        //thread3的node指向thread2的node
            node.prev = pred;
            //将tail节点的指向改成thread3的node
            if (compareAndSetTail(pred, node)) {
            //thread2的next指向thread3的节点
                pred.next = node;
                //返回thread3的node
                return node;
            }
        }
        enq(node);
        return node;
    }

//node为当前线程的node节点
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
            //获取node节点的前一个节点
                final Node p = node.predecessor();
                //如果p==head 如果是thread2,那么满足，但是thread2 tryAcquire失败，因为thread1占有锁；所以不满足
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //进入shouldParkAfterFailedAcquire与 parkAndCheckInterrupt
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

//pred为当前线程的前节点 node为当前线程节点
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;//得到节点的状态，默认为0 第二 次进入为-1
        if (ws == Node.SIGNAL)//waitStatus!=-1不满足 第二次 满足条件，返回true
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {//不满足
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
             //该逻辑是当我前一个节点的线程状态取消时，将前后链表的关系取消
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {//进入else
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
             //修改当前节点的前一个节点的状态为-1
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        //返回false,进入外面的自旋，
        return false;
    }

private final boolean parkAndCheckInterrupt() { 
	LockSupport.park(this); //如果没有拿到锁，线程park  waiting状态 唤醒有2个场景（1第一个线程释放锁唤醒 2interrupt优雅中断） 
	return Thread.interrupted(); //获取中断状态并且复位 
}

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

    public final boolean release(int arg) {
    //调用tryRelease方法 尝试释放锁
        if (tryRelease(arg)) {
        //如果锁释放成功
            Node h = head;
            //得到head节点，如果head节点!=null 并且状态！=0 满足条件
            if (h != null && h.waitStatus != 0)
            //执行unparkSuccessor
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

        protected final boolean tryRelease(int releases) {
        //假如thread1只重入了一次。c-1=0
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
            //判断加锁的线程是不是当前需要释放的线程
                throw new IllegalMonitorStateException();
            boolean free = false;
            //如果thread1只加锁一次
            if (c == 0) {
                free = true;
                //将当前拿锁线程设置为空
                setExclusiveOwnerThread(null);
            }
            //将state设置为0
            setState(c);
            return free;
        }

//node 为head节点
    private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
         //得到head的节点状态
        int ws = node.waitStatus;
        if (ws < 0)//现在的状态为-1 满足条件
            compareAndSetWaitStatus(node, ws, 0);//将头节点改成 0

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
         //得到head节点的下一个节点，我们的场景为thread2的
        Node s = node.next;
        //thread2node的状态为-1,正常状态
        if (s == null || s.waitStatus > 0) {
            s = null;
            //如果需要释放锁的那个线程是取消状态，从后往前找到最前面的那 一个node
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        //满足条件
        if (s != null)
        //唤醒thread2线程
            LockSupport.unpark(s.thread);
    }

    private Node enq(final Node node) {
    //自旋
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
            //node的前节点指向t
                node.prev = t;
                if (compareAndSetTail(t, node)) {
					//以下逻辑再其他现在执行完之后执行就会出现如下图场 景，所以必须从后往前
                    t.next = node;
                    return t;
                }
            }
        }
    }

private final boolean parkAndCheckInterrupt() { 
	LockSupport.park(this); //被释放锁唤醒，如果外面中断过范围false，否则返回true，并复位 
	return Thread.interrupted(); 
}

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
            //获取thread2 node的前节点
                final Node p = node.predecessor();
                //thread2的前节点是head，并且这个时候thread1已经释放 锁，能拿到锁 if
                if (p == head && tryAcquire(arg)) {
                //将thread2的节点设置为首节点，并且把thread2节点 的thread、pre设置为null
                    setHead(node);
                    //这个时候之前的node节点还存在强引用，将next关联 去除，方便回收之前的head节点
                    p.next = null; // help GC
                    failed = false;
                    //返回
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

protected final boolean tryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	int c = getState();
	if (c == 0) { 
		//获取锁加了条件hasQueuedPredecessors 
		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() { 
	// The correctness of this depends on head being initialized 
	// before tail and on head.next being accurate if the current 
	// thread is first in queue. 
	//先获取tail，防止tail不为空 head为空的情况 但是head为空， tail为空或者都为空没事 
	//保证不会h为空还进入h.next判断 
	Node t = tail; // Read fields in reverse initialization order 
	Node h = head; Node s; 
	return h != t && ((s = h.next) == null || s.thread != Thread.currentThread()); 
}

((s = h.next) == null || s.thread != Thread.currentThread());