21_可重入锁

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

Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

类似于家里面的大门,进入之后可以进入厕所、厨房等

---

“可重入锁”这四个字分开来解释:

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

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

---

可重入锁种类

隐式锁

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

同步块

package com.aqs;

/**
 * @Author: xj0927
 * @Description: 可重入锁:可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁，这样的锁就叫做可重入锁。
 * 在一个synchronized修饰的方法或代码块的内部
 * 调用本类的其他synchronized修饰的方法或代码块时，是永远可以得到锁的
 * @Date Created in 2021-01-25 10:39
 */
public class ReEnterLock {

    //锁对象
    static Object objectLockA = new Object();

    public static void m1() {
        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) {
        m1();
    }
}

结果：

---

同步方法

package com.aqs;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 10:48
 * @Modified By:
 */
public class ReEnterLock2 {

    public synchronized void m1() {
        System.out.println("=====外层");
        m2();
    }

    public synchronized void m2() {
        System.out.println("=====中层");
        m3();
    }

    public synchronized void m3() {
        System.out.println("=====内层");
    }

    public static void main(String[] args) {
        new ReEnterLock2().m1();
    }
}

---

Synchronized的重入的实现机理

每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针

当执行monitorenter时,如果目标锁对象的计数器为零,那么说明它没有被其他线程持有,Java虚拟机会将该锁对象

的持有线程设置为当前线程,并且将其计数器加1,否则需要等待,直至持有线程释放该锁

当执行monitorexit时,Java虚拟机则锁对象的计数器减1。计数器为零代表锁已经被释放

说明：第一个monitorexit是在方法执行完成时使用，第二个monitorexit是在发生异常时，能够保证锁的自动释放。

---

显示锁

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

package com.aqs;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 10:54
 * @Modified By:
 */
public class ReEnterLock3 {

    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();
    }
}

结果：

发现，同一个线程可以再次获取、释放同一把锁。

---

那如果现在加锁释放锁的次数不匹配：加锁两次，释放一次

package com.aqs;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 10:54
 * @Modified By:
 */
public class ReEnterLock3 {

    static Lock lock = new ReentrantLock();

    public static void main(String[] args) {

        new Thread(() -> {
            //加锁两次
            lock.lock();
            lock.lock();
            try {
                System.out.println("=======外层");
                lock.lock();
                try {
                    System.out.println("=======内层");
                } finally {
                    lock.unlock();
                }
            } finally {
                //只释放一次
                lock.unlock();
            }
        }, "t1").start();


        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t2 thread----外层调用lock");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

结果：

由于加锁次数和释放次数不一样，第二个线程始终无法获取到锁，导致一直在等待。

正常情况，加锁几次就要解锁几次

---