ReentrantLock整理

ReentrantLock内部有一个继承于AQS的Sync类，正如AQS源码里所说的：AQS的子类们应该被定义为非公开的内部辅助类，并且被用来实现它们外部类的其它内部类的同步属性，即ReentrantLock一样，一个Sync内部类实现了AQS的一些同步方法，并且内部公平和非公平锁类调用了这一些方法来进行锁操作。 AQS还为ReentrantLock提供了一个原子值state来表示状态，ReentrantLock定义了改变这个状态值的get和set方法，并且定义这个状态值的意义，用来获取或释放对象。

我们一般都是这样使用ReentrantLock： 1、private final Lock lock = new ReentrantLock() 2、private final Lock lock = new ReentrantLock(Boolean fair) 3、lock.lock() 4、lock.unlock()

构造方法：

首先，第一种方法调用了ReentrantLock的无参构造器，默认创建了一个NonfairSync对象，代码如下：

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

第二种会按照传的参数来构造公平或非公平锁的对象

public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); }

调用lock方法：

首先看内部类NonfairSync：

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

1、首先会直接判断State值，若为0，则将其置为1，并且将当前线程置为独享模式的持有者，并取得资源 2、否则会调用AQS中的acquire方法，然后acquire方法会调用NonfairSync中重写的tryAcquire方法来进行尝试获锁的判断

final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); /*首先调用AQS的getState方法来获取state状态，值默认初始为0*/ int c = getState(); /*为0，证明没有线程持有锁，利用原子操作将state+1，并将当前线程设为当前独享模式的持有者，然后返回true*/ if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } }

3、若锁已被当前线程所占有，即状态值不为0，则将当前状态值设置为：当前状态值加上acquires参数（默认为1）。然后返回true，证明再次获锁成功。这块代码为可重入的体现

else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); /*设置状态值为修改后的值*/ setState(nextc); /*成功获锁*/ return true; }

内部类FairSync：

final void lock() { acquire(1); }

这里是直接调用AQS中的acquire方法，然后acquire方法会调用FairSync中重写的tryAcquire方法来进行尝试获锁的判断

protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); /*获取state值*/ int c = getState(); /*公平的体现。若state为0*/ if (c == 0) {

当前节点为等待队列头节点并且能将state设置为acquires代表的值，则成功。这块代码与非公平锁不同的地方就在这，判断当前节点是否为头节点的操作，也是公平的体现，即每次只有队列中的第一个节点才能获取资源

if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } }

若锁已被当前线程所占有，即状态值不为0，则将当前状态值设置为：当前状态值加上acquires参数（默认为1）。然后返回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; } }

判断当前节点是否是队列中的第一个节点，是就返回false，不是则返回true

public final boolean hasQueuedPredecessors() { /* 1、若当前队列为空，则h==t，返回false 2、若当前队列只有一个节点，则返回false 3、否则若当前线程所属节点不为第二个节点，返回true；若等于，返回false*/ Node t = tail; Node h = head; Node s; return h != t && ((s = h.next) == null || s.thread != Thread.currentThread()); }

unlock的调用：

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

它会调用AQS的release方法，然后release方法调用Sync重写的tryRelease方法来释放资源

protected final boolean tryRelease(int releases) { /*将当前状态值减去releases（默认1）*/ int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); /*标志位，若c=0，则返回true，不为0.返回false*/ boolean free = false; /*若修改后的状态值为0，则证明可以释放，并将持有当前独享模式的线程置空*/ if (c == 0) { /*设置标志位为0*/ free = true; setExclusiveOwnerThread(null); } /*设置修改后的状态值*/ setState(c); /*若free返回true*/ return free; }