先看依赖结构图
按照锁的划分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获取了锁 |
从结果中看一看出，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获取了锁 |
从结果中可以看出，除非已经后期锁标记的线程全部执行完成并不再尝试获取锁标记，否则锁标记一直会被当前线程获取
在java中另外一个比较常见的可重入锁是synchrohized （非公平锁、可重入锁）关键字，关于synchrohized相关文章在整理中，完成后会放上连接