ReentrantLock简介
首先回顾一下synchronized关键字。
把代码声明为synchronized之后，那么就会保证，每次都只有一个线程获取对象的内部锁，进而产生互斥保证共享资源的安全。synchronized是获取对象的内部锁，所以是原生语法层面的互斥，需要JVM实现。
ReentrantLock是jdk1.5开始引入的JUC并发包中的一个类，ReentrantLock基于java代码实现，也就是API层面的互斥。ReentrantLock是锁的实现类，这就让它更具有灵活性，可以用多种算法来实现。而且在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上）
要理解ReentranLock.我们先从它的整体结构和阅读源码开始学习。
在学习前可以先看看ReentrantLock的基本工作流程。然后带着流程去理解源码。这个流程图是在学习之后总结出来的。这里在前面也放一份。
ReentrantLock类中的方法列表：
// 创建一个 ReentrantLock ，默认是“非公平锁”。
ReentrantLock()
// 创建策略是fair的 ReentrantLock。fair为true表示是公平锁，fair为false表示是非公平锁。
ReentrantLock(boolean fair)
// 查询当前线程保持此锁的次数。
int getHoldCount()
// 返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null。
protected Thread getOwner()
// 返回一个 collection，它包含可能正等待获取此锁的线程。
protected Collection<Thread> getQueuedThreads()
// 返回正等待获取此锁的线程估计数。
int getQueueLength()
// 返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。
protected Collection<Thread> getWaitingThreads(Condition condition)
// 返回等待与此锁相关的给定条件的线程估计数。
int getWaitQueueLength(Condition condition)
// 查询给定线程是否正在等待获取此锁。
boolean hasQueuedThread(Thread thread)
// 查询是否有些线程正在等待获取此锁。
boolean hasQueuedThreads()
// 查询是否有些线程正在等待与此锁有关的给定条件。
boolean hasWaiters(Condition condition)
// 如果是“公平锁”返回true，否则返回false。
boolean isFair()
// 查询当前线程是否保持此锁。
boolean isHeldByCurrentThread()
// 查询此锁是否由任意线程保持。
boolean isLocked()
// 获取锁。
void lock()
// 如果当前线程未被中断，则获取锁。
void lockInterruptibly()
// 返回用来与此 Lock 实例一起使用的 Condition 实例。
Condition newCondition()
// 仅在调用时锁未被另一个线程保持的情况下，才获取该锁。
boolean tryLock()
// 如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。
boolean tryLock(long timeout, TimeUnit unit)
// 试图释放此锁。
void unlock()在来看一下它的源码，如果贴上全部源码可能会看的有点头晕。所以可以自行在Eclipse中打开源码。这里做一个简单的归类，以及后面一点一点的读。如图：
类图，ReentrantLock是Lock类的实现类，它有一个自己的内部类Sync.ReentrantLock将Lock类的大部分实现，全部委托给了Sync来实现。现，AbstractQueuedSynchronizer中抽象了绝大多数Lock的功能，而只把tryAcquire方法延迟到子类中实现。Sync同时有两个子类，一个就是用于公平锁，一个用于非公平锁。下面就学习一下，是如何实现的。
锁的实现（加锁）
查看ReentrantLock API可以看到有一个方法lock()获取锁。源码如下：
public void lock() {
sync.lock();
}
前面说了，大部分实现都是委托给了Sync这个类。而Sync有两个子类，先学习公平锁，理解了公平锁，对于非公平锁也容易多了。因此查看Sync子类 FairSync中的 lock()方法：
final void lock() {
acquire(1);
}发现调用了一个acquire(1)方法，这个方法是干嘛的呢？从类图可以看到Sync继承了AbstractQueuedSynchronizer。而acquire(1)就是其AQS的一个方法。点击查看源码：
/**
* Acquires in exclusive mode, ignoring interrupts. Implemented
* by invoking at least once {@link #tryAcquire},
* returning on success. Otherwise the thread is queued, possibly
* repeatedly blocking and unblocking, invoking {@link
* #tryAcquire} until success. This method can be used
* to implement method {@link Lock#lock}.
*
* @param arg the acquire argument. This value is conveyed to
* {@link #tryAcquire} but is otherwise uninterpreted and
* can represent anything you like.
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}看其注释，这个方法是独占模式下的一个方法，并且忽略中断。如果获取到资源，就直接返回，否则就进入一个队列。直到获取到资源为止。我们获取资源第一个真方法可以说是这个才正式开始，那么这个方法也可以理解为独占模式下获取资源的顶层入口。然后分析方法：
方法中有一个判断，如果为真，就执行一个方法 selfInterrupt()。从方法名称来看，这个是自我中断。那么综合方法的注释——在获取资源时候，忽略中断。知道获取资源。那么方法就可以拆分2部分
1.获取资源，然后判断。
2.根据判断的真假决定是否执行自我中断（selfInterrupt()）
先看第一步，if中包含两个方法。
1.tryAcquire(arg)
2.acquireQueued(addWaiter(Node.EXCLUSIVE), arg));
tryAcquire(arg)
tryAcquire是Sync的一个方法。源码：
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
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;
}
}该方法表示试图获取锁，如果获取成功直接返回true否则返回false。这里又分为2步骤
1.判断c是否等于0. 如果c等于0，那么就判断中执行hasQueuedPredecessors() 与compareAndSetState(0, acquires)。如果条件为真，就执行 setExclusiveOwnerThread(current) 并返回ture。
hasQueuedPredecessors 方法
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.
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());
}这个方法就是判断当队列中是否有其它线程，如果没有，说明没有线程占有着锁。关于这个线程队列，下次会做个详细学习笔记。所以当hasQueuedPredecessors 返回false，说明当前队列没有线程，那么就执行compareAndSetState(0, acquires)方法。这个方法其实就是前面学习过类似的方法，CAS更新。把state更新为1.然后把独占线程设置为当前线程，就是说让当前线程获取到资源
那么为什么非得是c==0进来呢。那就看一下c不等于0是怎么执行的。
不等与0的时候执行current == getExclusiveOwnerThread()判断当前线程是否就是当前占锁的线程。那么这就可以理解，如果c==0就是说这个时候锁是空着的，没有任何线程占有，不等于0就是说明锁被占着。所以在上面，当更新完状态之后，我们就把锁给当前线程。那锁被占了为什么还要判断锁是不是当前线程占有，这是因为ReentrantLock是可重入锁，所以就要判断一次。如果是，就把c加上acquires然后更新状态值。返回。
这样我们就梳理一下：
在lock中调用的acquire(1),这个常量1就代表锁获取一次就需要更新的状态值，如果是第一次获取资源，则变为1，如果是重入那么就在原来的基础上加1.因此：ReentrantLock的锁的一个机制，是每当线程获取一次相同锁，就进行一次计数加1.同理，如果释放一次就减1.如果计数为0说明就是释放了锁
总结tryAcquire方法就是尝试的去获取一下资源，如果获取就返回true否则返回false.
因此在在尝试获取失败后再执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法。
addWaiter 方法
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) { //队列不为空就加入
node.prev = pred;
if (compareAndSetTail(pred, node)) { //进行CAS操作更新节点。如果失败代表有并发，进入enq方 法
pred.next = node;
return node;
}
}
enq(node);
return node;
}
嗯！在分析这个源码之前，先来看一下Node是什么。
static final class Node {
/** Marker to indicate a node is waiting in shared mode */
static final Node SHARED = new Node();
/** Marker to indicate a node is waiting in exclusive mode */
static final Node EXCLUSIVE = null;
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
volatile int waitStatus;
volatile Node prev;
volatile Thread thread;
Node nextWaiter;
final boolean isShared() {
return nextWaiter == SHARED;
}
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() { // Used to establish initial head or SHARED marker
}
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { // Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}首先他是AbstractQueuedSynchronizer的一个静态的内部类。这个跟LinkedList源码中的Node类似。我们刚才说的队列就是由这个Node组成。组成的队列就是AQS中的CLH队列。关于CLH队列后续会写一遍学习笔记来仔细记录。这里我们需要理解的就是这个Node会把在一个个获取资源的线程串联成一个FIFO（先进先出）的队列。这样就保证了公平性。因此addWaiter 就是如果这个队列不为空就直接把线程加入队列，加入失败就代表有并发竞争，那就进入enq死循环。直到添加成功为止
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}OK。这个时候线程已经被封装成一个节点，并且加入了队列中。接下来要做一件什么事情呢？线程加入队列不可能还要一直运行着。所以需要将它挂起来。所以这个任务就交给acquireQueued来实现。
acquireQueued
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);
p.next = null; // help GC
failed = false;
return interrupted; //此处返回false.就是避免前面selfinterrupt方法执行。
}
if (shouldParkAfterFailedAcquire(p, node) && //如果不当前节点不是头节点或者头节点获取资源失败。那么就意味着要等待头节点的下一次获取，那么判断当前线程是否需要挂起。
parkAndCheckInterrupt()) //如果当前线程需要挂起就调用LockSupport类中的park方法将线程挂起。然后进入下一次循环。
interrupted = true;
}
} finally {
if (failed) //抛出异常就把节点从队列中移除
cancelAcquire(node);
}
}
shouldParkAfterFailedAcquire
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* 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 {
/*
* 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.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}判断当前是否需要挂起是通过 waitStatus值来判断。
Node节点中，除了存储当前线程，节点类型，队列中前后元素的变量，还有一个叫waitStatus的变量，改变量用于描述节点的状态，为什么需要这个状态呢？
原因是：AQS的队列中，在有并发时，肯定会存取一定数量的节点，每个节点 代表了一个线程的状态，有的线程可能可能“等不及”获取锁了，需要放弃竞争，退出队列，有点线程在等待一些条件满足，满足后才恢复执行（这里的描述很像某个J.U.C包下的工具类，ReentrankLock的Condition，事实上，Condition同样也是AQS的子类）等等，总之，各个线程有各个线程的状态，但总需要一个变量买描述它，这个变量就叫waitStatus,它有四种状态：
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
**重点内容** static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
CANCELLED：因为超时或者中断，结点会被设置为取消状态，被取消状态的结点不应该去竞争锁，只能保持取消状态不变，不能转换为其他状态。处于这种状态的结点会被踢出队列，被GC回收；
SIGNAL：表示这个结点的继任结点被阻塞了，到时需要通知它；
CONDITION：表示这个结点在条件队列中，因为等待某个条件而被阻塞；
PROPAGATE：使用在共享模式头结点有可能牌处于这种状态，表示锁的下一次获取可以无条件传播；
当且仅当前一个节点处于SIGNAL时候，才需要挂起。
释放锁
获取锁之后，是必须要在最后释放锁的。理解了获取锁，释放锁就容易多了。
释放操作需要做哪些事情：
1. 因为获取锁的线程的节点，此时在AQS的头节点位置，所以，可能需要将头节点移除。
2. 而应该是直接释放锁，然后找到AQS的头节点，通知它可以来竞争锁了。
到此ReentrantLock的公平锁基本分析完毕。那么还有一个非公平锁。非公平锁其实就是抢占式的。先看源码：
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}源码中就是非公平锁的实现，就是在执行公平锁之前，先不管三七二十一，先去获取一次锁，如果获取成功，直接返回，否则就老老实实的排队进入公平锁。让我想到买火车票排队。人太多，有些人就懒得排队，就会跑到最前面问售票员，可不可以帮我先买一张，我很急。售票员如果给一个白眼，那么他就公平了，如果售票员同情心起来，卖给他，那就非公平性了。
总结
源码的学习就在于能知其然。所以可能学习的过程会比较困难。但是希望自己坚持这种学习方式。到这里ReentrantLock基本学习分析完毕。其中涉及到的CLH队列。会做一个新的篇章学习。最后画一个流程图。来表示ReentrantLock的基本流程：
扫一扫
311
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
