先看依赖结构图
按照锁的划分ReentrantLock是可重入锁；
所谓重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。
首先上一下测试代码
private static final Lock lock=new ReentrantLock(true); //定义一个可重入的公平锁
public static void main(String[] args) { //
new Thread(()->test(),"线程A").start();
new Thread(()->test(),"线程B").start();
}
public static void test(){ //test加锁调用同样加锁的test2
for(int i=0;i<2;i++){
lock.lock();
System.out.println(Thread.currentThread().getName()+"获取了锁");
test2();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock(); //手动释放锁
}
}
}
public static void test2(){
lock.lock(); //加锁
try {
System.out.println(Thread.currentThread().getName()+"获取了锁,执行Test2");
} finally {
lock.unlock(); //手动释放锁
} }
执行结果如下：
| 线程A获取了锁 线程A获取了锁,执行Test2 线程B获取了锁 线程B获取了锁,执行Test2 线程A获取了锁 线程A获取了锁,执行Test2 线程B获取了锁 线程B获取了锁,执行Test2 |
从结果中看一看出，test()中获取了锁，在不释放锁的情况下，调用相同线程的test2()再次获取锁，是可以获取的，这就是锁的”重入“的概念；
那”重入“是如何实现的呢？
对ReentrantLock来说，其操作的是其内部类Sync的父类AQS中的被volatite标记的state属性，每次调用lock()方法其实都对state+1，每次unlock时候就-1，当state==0时，标识当前没有人持有锁标记，其他线程可以顺利的获取锁标记 ；
不知道你注意没有，Test()方法中是有两个循环的，但是执行的顺序是却是执行了一遍后，接着执行B线程了。这是因为我们创建的lock是公平锁，当state==0（锁释放）时，重新唤醒线程获取锁的标准是等待最长原则，这就是”公平锁”的概念；
ReentrantLock获取锁标记有“公平锁”和“非公平锁”两种实现对应的是Sync的两个子类FairSync和NonfairSync；
ReentrantLock默认是非公平锁，除非在创建的时候传入true，才会创建公平锁
public ReentrantLock() {
sync = new NonfairSync(); //初始化一个非公平锁实例
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync(); //根据fair值进行判断，true时创建的为公平锁
}
首先看一下公平锁的Lock方法
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
@ReservedStackAccess
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) { //如果锁标记空闲
if (!hasQueuedPredecessors() && //首先判断AQS的FiFO队列中是否有前序节点，如果没有才尝试获取锁标记
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) { //如果锁标记被占有，判断占有者是不是本线程，如果是则state+1
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false; //否则返回false，进入AQS的FiFO队列，并等待唤醒
}
}
上边代码中hasQueuedPredecessors()方法就是公平锁与非公平锁最大的区别，公平锁会按照线程进入等待队列的顺序进行唤醒；为了更好的理解，我们看一下非公平锁的代码
/**
* Sync object for non-fair locks
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
@ReservedStackAccess
final void lock() {
if (compareAndSetState(0, 1)) //如果当前锁标记为0，则锁成功
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1); //尝试获取锁
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
@ReservedStackAccess
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}else if (current == getExclusiveOwnerThread()) { //如果当前线程是活跃线程，那么直接获取锁标记，这就是最后边的例子中，线程A一直霸占锁标记的原因
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc); return true; } return false; }
无论是公平锁还是非公平锁都调用了AQS中的accquire()方法，上代码
@ReservedStackAccess
public final void acquire(int arg) {
if (!tryAcquire(arg) && //调用子类中实现的抽象方法尝试获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //获取失败加入到等待队列中
selfInterrupt(); //线程增加中断标记
}
到这里关于公平锁和非公平锁的实现已经讲完了，在锁获取的时候有个重要的类ASQ（抽象队列同步器）关于ASQ在另外一篇文章中进行了讲解，并持续更新；
说了两者的区别，我们来看看上面的例子中，如果是非公平锁，会是什么效果
private static final Lock lock=new ReentrantLock(); //创建非公平锁
| 线程A获取了锁 线程A获取了锁,执行Test2 线程A获取了锁 线程A获取了锁,执行Test2 线程B获取了锁 线程B获取了锁,执行Test2 线程B获取了锁 线程B获取了锁,执行Test2 |
从结果中可以看出，除非已经后期锁标记的线程全部执行完成并不再尝试获取锁标记，否则锁标记一直会被当前线程获取
在java中另外一个比较常见的可重入锁是synchrohized （非公平锁、可重入锁）关键字，关于synchrohized相关文章在整理中，完成后会放上连接
