可重入锁

可重入锁

可重入锁，又名递归锁，是指同一个线程在外层方法获取锁的时候，再进入该线程内层方法会自动获取锁（前提，锁对象是同一个对象），不会因为之前已经获取过还没释放而阻塞。
Java中的ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点就是可一定程度避免死锁。

1. 一个线程中的多个流程可以获取同一把锁，持有这把同步锁可以再次进入。
2. 自己可以获取自己的内部锁。（否则自己又要等着自己释放锁再获取锁）

可重入锁的种类

1. 隐式锁（即synchronized关键字使用的锁）默认是可重入锁

//在一个Synchronized修饰的方法或代码块的内部，调用本类的其他Synchronized修饰的方法或代码块时，是永远可以得到锁的。
//同步代码块
static Object objectLockA = new Object();

    public static void thread(){

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

//输出结果
t1	---外层调用
t1	---中层调用
t1	---内层调用

//同步方法
public static synchronized void thread1(){
        System.out.println("====外");
        thread2();
    }
    public static synchronized void thread2(){
        System.out.println("====中");
        thread3();
    }
    public static synchronized void thread3(){
        System.out.println("====内");
    }

    public static void main(String[] args) {
        thread1();
    }

//输出结果
====外
====中
====内

Synchronized的重入的实现机理：

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

2. 显示锁（即Lock）也有ReentrantLock这样的可重入锁。

static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() ->{
            lock.lock();
            try{
                System.out.println("====外层");
                lock.lock();
                try{
                    System.out.println("====内层");
                }finally {
                    lock.unlock();
                }
            }finally {
                lock.unlock();
            }
        }, "t1").start();
    }

//输出结果
====外层
====内层