所谓重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。
synchronized 和 ReentrantLock 都是可重入锁。
可重入锁的意义在于防止死锁。
可重入锁简单演示
什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。
ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样
例如
//演示可重入锁是什么意思，可重入，就是可以重复获取相同的锁，synchronized和ReentrantLock都是可重入的 //可重入降低了编程复杂性 public class WhatReentrant { public static void main(String[] args) { // TODO Auto-generated method stub new Thread(new Runnable() { @Override public void run() { synchronized (this) { System.out.println("第1次获取锁，这个锁是：" + this); int index = 1; while (true) { synchronized (this) { System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this); } if (index == 10) { break; } } } } }).start(); } }
//演示可重入锁是什么意思 public class WhatReentrant2 { public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock); try { Thread.sleep(new Random().nextInt(200)); } catch (InterruptedException e) { e.printStackTrace(); } if (index == 10) { break; } } finally { lock.unlock(); } } } finally { lock.unlock(); } } }).start(); } }
可以发现没发生死锁，可以多次获取相同的锁
可重入锁有
- synchronized
- ReentrantLock
使用ReentrantLock的注意点
ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样
以下代码演示，加锁和释放次数不一样导致的死锁
public class WhatReentrant3 { public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); System.out.println("第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock); try { Thread.sleep(new Random().nextInt(200)); } catch (InterruptedException e) { e.printStackTrace(); } if (index == 10) { break; } } finally { // lock.unlock();// 这里故意注释，实现加锁次数和释放次数不一样 } } } finally { lock.unlock(); } } }).start(); new Thread(new Runnable() { @Override public void run() { try { lock.lock(); for (int i = 0; i < 20; i++) { System.out.println("threadName:" + Thread.currentThread().getName()); try { Thread.sleep(new Random().nextInt(200)); } catch (InterruptedException e) { e.printStackTrace(); } } } finally { lock.unlock(); } } }).start(); } }
可以看出，由于加锁次数和释放次数不一样，第二个线程始终无法获取到锁，导致一直在等待。
稍微改一下，在外层的finally里头释放9次，让加锁和释放次数一样，就没问题了
try { lock.lock(); System.out.println("第1次获取锁，这个锁是：" + lock); int index = 1; while (true) { try { lock.lock(); System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock); ... 代码省略节省篇幅... } finally { // lock.unlock();// 这里故意注释，实现加锁次数和释放次数不一样 } } } finally { lock.unlock(); // 在外层的finally里头释放9次，让加锁和释放次数一样，就没问题了 for (int i = 0; i < 9; i++) { lock.unlock(); } }
实现原理
实现原理是通过为每个锁关联一个请求计数器和一个占有它的线程。
当计数为0时，认为锁是未被占有的；线程请求一个未被占有的锁时，JVM将记录锁的占有者，并且将请求计数器置为1 。
如果同一个线程再次请求这个锁，计数将递增；
每次占用线程退出同步块，计数器值将递减。直到计数器为0,锁被释放。
关于父类和子类的锁的重入:子类覆写了父类的synchonized方法，然后调用父类中的方法，此时如果没有重入的锁，那么这段代码将产生死锁（很好理解吧）。
例子：
比如说A类中有个方法public synchronized methodA1(){
methodA2();
}
而且public synchronized methodA2(){
//具体操作
}
也是A类中的同步方法，当当前线程调用A类的对象methodA1同步方法，如果其他线程没有获取A类的对象锁，那么当前线程就获得当前A类对象的锁，
然后执行methodA1同步方法，方法体中调用methodA2同步方法，当前线程能够再次获取A类对象的锁，而其他线程是不可以的，这就是可重入锁。
代码演示：
不可重入锁：
public class Lock{ private boolean isLocked = false; public synchronized void lock() throws InterruptedException{ while(isLocked){ wait(); } isLocked = true; } public synchronized void unlock(){ isLocked = false; notify(); }
使用该锁：
public class Count{ Lock lock = new Lock(); public void print(){ lock.lock(); doAdd(); lock.unlock(); } public void doAdd(){ lock.lock(); //do something lock.unlock(); } }
当前线程执行print()方法首先获取lock，接下来执行doAdd()方法就无法执行doAdd()中的逻辑，必须先释放锁。这个例子很好的说明了不可重入锁。
可重入锁：
接下来，我们设计一种可重入锁
public class Lock{ boolean isLocked = false; Thread lockedBy = null; int lockedCount = 0; public synchronized void lock() throws InterruptedException{ Thread thread = Thread.currentThread(); while(isLocked && lockedBy != thread){//锁已经被获取了，并且不是这个线程获取的，就等待 wait(); } isLocked = true; lockedCount++; lockedBy = thread; } public synchronized void unlock(){ if(Thread.currentThread() == this.lockedBy){ lockedCount--; if(lockedCount == 0){ isLocked = false; notify(); } } } }
所谓可重入，意味着线程可以进入它已经拥有的锁的同步代码块儿。
我们设计两个线程调用print()方法，第一个线程调用print()方法获取锁，进入lock()方法，
由于初始lockedBy是null，所以不会进入while挂起当前线程，而是是增量lockedCount并记录lockBy为第一个线程。
接着第一个线程进入doAdd()方法，由于是同一线程，所以不会进入while挂起线程，接着增量lockedCount，
当第二个线程尝试lock，由于isLocked=true,所以他不会获取该锁，直到第一个线程调用两次unlock()将lockCount递减为0，才将标记为isLocked设置为false。
可重入锁的概念和设计思想大体如此，Java中的可重入锁ReentrantLock设计思路也是这样。
synchronized和ReentrantLock 都是可重入锁。
ReentrantLock与synchronized比较：
- 前者使用灵活，但是必须手动开启和释放锁
- 前者扩展性好，有时间锁等候（tryLock( )），可中断锁等候（lockInterruptibly( )），锁投票等，适合用于高度竞争锁和多个条件变量的地方
- 前者提供了可轮询的锁请求，可以尝试去获取锁（tryLock( )），如果失败，则会释放已经获得的锁。有完善的错误恢复机制，可以避免死锁的发生。
https://blog.csdn.net/w8y56f/article/details/89554060
https://blog.csdn.net/qq_39101581/article/details/82144499