ReentrantLock源码解读

ReentrantLock构造函数：

    // 无参构造函数，默认非公平
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    // 有参构造函数，参数：是否公平
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

看下在ReentrantLock中的内部类Sync：

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
    
        abstract void lock();
		// 调用场景:NonfairSync.lock()->acquire(1)（使用原子类更新state失败的场景下）
        final boolean nonfairTryAcquire(int acquires) {
        	// 获取当前线程
            final Thread current = Thread.currentThread();
            // 获取线程获取独占锁的次数
            int c = getState();
            if (c == 0) {
            	// 原子性的更新state
                if (compareAndSetState(0, acquires)) {
                	// 若成功，并设置获取锁的线程为当前线程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 若获得锁的线程是当前线程
            else if (current == getExclusiveOwnerThread()) {
            	// 在state的基础上加上参数acquires的值
            	// 这就是重入锁的实现逻辑
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                // 更新state
                setState(nextc);
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {
        	// 重入锁的实现，类似一个计数器的逻辑
            int c = getState() - releases;
             // 是否为当前线程
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
             // 记录线程获取锁的次数为0则说明可以释放锁了
            if (c == 0) {
                free = true;
                // 将当前获取锁的线程设为null
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
        
		 // 是否当前线程获得独占锁
        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }
		
		// 返回获得锁的线程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }
		
		// 返回线程获取线程的次数
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
		
		// 是否有线程获取到锁
        final boolean isLocked() {
            return getState() != 0;
        }

        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

Sync又有两个子类，分来用来实现非公平锁（默认）与公平锁，先看非公平锁的实现：

    static final class NonfairSync extends Sync {
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

接下来看公平锁的实现：

     static final class FairSync extends Sync {
           final void lock() {
               // 调的是上面父类Sync的父类AbstractQueuedSynchronizer的acquire()
               acquire(1);
           }
           protected final boolean tryAcquire(int acquires) {
               final Thread current = Thread.currentThread();
               int c = getState();
               if (c == 0) {
                   // hasQueuedPredecessors():通过判断"当前线程"是不是在CLH队列的队首，
                   // 来返回AQS中是不是有比“当前线程”等待更久的线程
                   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;
           }
       }

所以对比公平锁与非公平锁的实现，其实就是公平锁的tryAcquire(int acquires) 中多了一个!hasQueuedPredecessors()的判断，用来判断"当前线程"是不是在CLH队列的队首，来返回AQS中是不是有比“当前线程”等待更久的线程，实现如下：

    public final boolean hasQueuedPredecessors() {
        Node t = tail;
        Node h = head;
        Node s;
        // h!=t:队列不为空
        // (s = h.next) == null：队列为空
        // s.thread != Thread.currentThread()：头结点的下一个线程不是当前线程
        return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
    }

ReentrantLock获取锁的方法调用顺序

// 所在类：NonfairSync or FairSync
1、final void lock()
// 所在类：AbstractQueuedSynchronizer 实际arg写死成1了
2、public final void acquire(int arg)
// 所在类：NonfairSync or FairSync 实际acquires写死成1了
3、protected final boolean tryAcquire(int acquires)