可重入锁（递归锁）

介绍

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提，锁对象得是同一个对象)，不会因为之前已经获取过还没释放而阻塞。

如果是1个有 synchronized 修饰的递归调用方法，程序第 2 次进入被自己阻塞了岂不是天大的笑话，出现了作茧自缚。所以 Java 中 ReentrantLock 和 synchronized 都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

解释

可：可以
重：再次
入：进入
锁：同步锁
进入什么：进入同步域（即同步代码块/方法或显式锁锁定的代码）

一个线程中的多个流程可以获取同一把锁，持有这把同步锁可以再次进入；自己可以获取自己的内部锁。

可重入锁种类

Synchronized 的重入的实现机理

为什么任何一个对象都可以成为一个锁
 objectMonitor.hpp

每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。
当执行 monitorenter 时，如果目标锁对象的计数器为零，那么说明它没有被其他线程所持有，Java 虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加 1。
在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么 Java 虚拟机可以将其计数器加 1，否则需要等待，直至持有线程释放该锁。
当执行 monitorexit 时，Java 虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放。

隐式锁

即 synchronized 关键字使用的锁，默认是可重入锁

指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁，这样的锁就叫做可重入锁。

简单的来说就是：在一个 synchronized 修饰的方法或代码块的内部调用本类的其他 synchronized 修饰的方法或代码块时，是永远可以得到锁的；与可重入锁相反，不可重入锁不可递归调用，递归调用就发生死锁。

同步块

ReEntryLockDemo.java

public class ReEntryLockDemo {
    public static void main(String[] args) {
        final Object object = new Object();
        new Thread(() -> {
            synchronized (object) {
                System.out.println(Thread.currentThread().getName() + "\t" + "外层调用");
                synchronized (object) {
                    System.out.println(Thread.currentThread().getName() + "\t" + "中层调用");
                    synchronized (object) {
                        System.out.println(Thread.currentThread().getName() + "\t" + "内层调用");
                    }
                }
            }
        }, "t1").start();
    }
}

同步方法

ReEntryLockDemo.java

public class ReEntryLockDemo {
 
    public synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + "\t-----start-----");
        m2();
        System.out.println(Thread.currentThread().getName() + "\t-----end-----");
    }
 
    public synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + "\t-----start-----");
        m3();
    }
 
    public synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + "\t-----start-----");
    }
 
    public static void main(String[] args) {
        ReEntryLockDemo reEntryLockDemo = new ReEntryLockDemo();
        new Thread(reEntryLockDemo::m1, "t1").start();
    }
}

显式锁

即 Lock，也有 ReentrantLock 这样的可重入锁

ReEntryLockDemo.java

public class ReEntryLockDemo {
    static Lock lock = new ReentrantLock();
 
    public static void main(String[] args) {
        new Thread(() -> {
            lock.lock();
            try
            {
                System.out.println(Thread.currentThread().getName() + "\t 外层调用lock");
                lock.lock();
                try
                {
                    System.out.println(Thread.currentThread().getName() + "\t 内层调用lock");
                }finally {
                    // 这里故意注释，实现加锁次数和释放次数不一样
                    // 由于加锁次数和释放次数不一样，第二个线程始终无法获取到锁，导致一直在等待。
                    lock.unlock(); // 正常情况，加锁几次就要解锁几次
                }
            }finally {
                lock.unlock();
            }
        },"a").start();
 
        new Thread(() -> {
            lock.lock();
            try
            {
                System.out.println(Thread.currentThread().getName() + "\t 外层调用lock");
            }finally {
                lock.unlock();
            }
        },"b").start();
    }
 
}

公平锁和非公平锁死锁及排查