写在前面：
在之前的博客中，我们总结了队列同步器的方法，在这篇博客中，将会总结Lock的实现类ReentrantLock，在ReentrantLock类的内部，就有一个内部类，继承了我们之前讨论过的队列同步器，我们也一起来看看队列同步器的实际应用。
公平锁和非公平锁：
在讲解ReentrantLock类之前，我们先引入一个概念--公平锁和非公平锁。
我们可以想象一个场景，比如说：火车站里，大家都在排队取车票，那么自然是队头第一个取票(队头是当前队列中排队时间最长的)，然后依次类推，这种方式，我们就可以成为公平锁。而如果在取票过程中，不断的有人插队，即不是当前队列排队时间最长的人在取票，那么这种方式，就是非公平锁。
下面，我们将场景还原成计算机语言，取票机器就好比是锁，每一个人排队的人就好比一个个线程，每一个线程都在队列中等待锁，这就产生了公平锁和非公平锁的概念，公平锁即先对锁发出请求的线程第一个获得了锁，反之，则是非公平锁。（不知道这样解释大家有没有理解呢？）
注：由于公平锁的效率比较低，所以在不以TPS(Transaction Per Seconds)为主要性能指标的情况下，我们实际应用中，多数情况下，还是使用非公平锁。
ReentrantLock：
在讨论过公平锁和非公平锁之后，我们再来回到主题ReentrantLock---重入锁。
- 概念：
从字面上来看，就是支持可以重新进入的锁，表示能够支持一个线程对资源的重复加锁。
- 引入：
在有synchronized关键字保护的方法中，线程在第一次获得锁，释放锁之后，仍然可以再次获得锁，就拥有访问资源的权利。但是未加入synchronized的方法中，就不允许线程再次进入，再次请求获得锁的时候，就会进入阻塞状态。这对于我们的实际应用就有了很多的障碍，所以，我们引入了重入锁，就保障了线程对资源的再次使用。
这样，我们综合前一篇博客队列同步器(http://blog.csdn.net/may_3/article/details/79460500)以及刚刚说的公平锁、非公平锁，ReentrantLock是支持公平锁和非公平锁双重实现的一种可重入锁。
- ReentrantLock的构造器：
ReentrantLock提供了两个构造器，在初始化ReentrantLock实例的时候，我们可以使用默构造器(无参，默认是非公平锁)或者传入一个参数的构造器，来指定公平锁还是非公平锁。
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
} 了解了构造器之后，我们可以通过Java APi了解一下ReentrantLock类的结构：
(1) 包含一个继承于队列同步器的Sync类，重写了队列同步器的相关方法，拓展了功能。
(2)包含一个FairSync类和一个UnFairSync类，他们都继承于Sync类，又对Sync的功能进行了拓展。
(3)提供了一个lock方法获取锁，提供了一个unlock方法释放锁
(4)其他锁方法
接下来，我们就先来看ReentrantLock的非公平锁实现：
- 非公平锁的获取锁lock方法：
public void lock() {
sync.lock();
}调用Sync类对象的lock方法，然后又会找到UnFairSync重写的lock方法。
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}在lock方法在，先用一个CAS(compareAndSetState)来判断state是否为0(如果为0表示锁未被占用)，而如果当前state为0则将state设置为1,然后设置当前线程为锁的独占线程，其他的线程就要进入阻塞状态，等待锁的释放。
这时候，就用到了，我们刚刚说的非公平锁，如果一旦刚刚获得锁的线程释放了锁，那么很可能一个新请求的线程在其他线程之前抢到了锁，这就是非公平锁。
刚刚为获得锁的线程也就进入了else中，调用acquire方法：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}先看逻辑&&的前半部分tryAcquire方法
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
} final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();//获取当前线程
int c = getState();//获取state值
if (c == 0) {//没有线程占用锁
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {//当前线程已经占用锁
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);//更新state的重入次数
return true;
}
return false;
}那么我们再回头看刚刚acquire方法if语句中的后半部分，我们再把代码拿过来，方便查看：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}后半部分是一个acquiredQueued(addWaiter(Node.EXCLUSIVE),arg),先来分析addWaiter方法：
addWaiter方法是队列同步器中的方法，传入NODE.EXCLUSIVE表示独占模式，
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);//初始化节点的关联线程和模式(独占还是共享)
Node pred = tail;//获得尾节点的引用
if (pred != null) {//如果尾节点不为空，则说明队列已经初始化过
node.prev = pred;
if (compareAndSetTail(pred, node)) {//CAS设置新节点为尾节点
pred.next = node;
return node;
}
}
enq(node);//说明队列并未初始化
return node;
} private Node enq(final Node node) {
for (;;) {//开始自旋
Node t = tail;
if (t == null) { // 如果tail为空，则新建节点并设置为head
if (compareAndSetHead(new Node()))
tail = head;
} else {//如果不为空则设置为尾节点
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}enq方法中描述了节点的自旋过程。假设有多个线程等待进入队列，首先for循环的if语句通过CAS设置head节点，且只能有一个线程设置为head节点，并将head赋值给tail，当一个线程设置成head节点，则其他线程会继续for循环，因为队列有了尾节点，所以下次进入，都会进入else语句，且有一个线程设置成尾节点，另外一个线程再次进入for循环，直到所有线程都进入队列。
从enq方法返回后，进入acquiredQueued方法，这个方法，让已经入队的线程尝试获取锁。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;//标记是否成功获取到锁
try {
boolean interrupted = false;//标记线程是否被中断
for (;;) {
final Node p = node.predecessor();//获取前驱节点的引用
if (p == head && tryAcquire(arg)) {//如果前驱节点是头节点，那么就有尝试获取锁的资格
setHead(node);//如果获取成功，则设置为head节点
p.next = null; // 原head的节点出队，被GC回收
failed = false;//获取到锁
return interrupted;
}//判断获取失败是否可以被挂起，如果可以，则被挂起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;//若被中断，则设置为true
}
} finally {
if (failed)
cancelAcquire(node);
}
}private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0)
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
- 非公平锁的释放锁unlock方法：
public void unlock() {
sync.release(1);
} public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}释放锁的流程，首先会尝试释放锁，然后如果head不为空会唤醒后继节点所关联的线程。释放失败，则返回false。下面是tryRelease的实现。
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}公平锁的实现：
公平锁和非公平锁的实现不同之处在于，非公平锁会检查锁的状态，而公平锁则不会。
扫一扫
2454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
