Java递归锁（可重入锁）

Java里面递归锁又叫可重入锁

1. 定义

   同一个线程在内层方法获取到锁之后，在进入内层方法会自动获取锁

   也就是说

   线程可以进入任何一个他已经拥有的锁所同步着的代码块

2. 代码验证

   lock 和 synchronized 都是递归锁

   2.1 synchronized 代码验证

   /**
    * @Author: xiaoshijiu
    * @Date: 2019/11/25
    * @Description: synchronized递归锁代码验证
    */
   public class SynchTest {
   
       public synchronized void test() {
           System.out.println(Thread.currentThread().getName());
           // 调用test2方法，test2方法也是经过synchronized加锁的方法
           test2();
       }
   
       public synchronized void test2() {
           System.out.println(Thread.currentThread().getName());
       }
   
       public static void main(String[] args) {
           SynchTest synchTest = new SynchTest();
           for (int i = 0; i < 5; i++) {
               new Thread(() -> {
                   synchTest.test();
               }, "T" + i).start();
           }
       }
   
       /**
        * 运行结果表明：同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁
        * 即递归锁
        */
   }
   

   运行结果
   
   运行结果表明：内层方法虽然加锁了，但是并不需要再竞争锁资源，即
   同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁，即递归锁

   2.2 lock 代码验证

   import java.util.concurrent.locks.Lock;
   import java.util.concurrent.locks.ReentrantLock;
   
   /**
    * @Author: xiaoshijiu
    * @Date: 2019/11/25
    * @Description: Lock是递归锁代码验证
    */
   public class LockTest {
   
       Lock lock = new ReentrantLock();
   
       public void test() {
           lock.lock();
           try {
               System.out.println(Thread.currentThread().getName());
               test2();
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               lock.unlock();
           }
       }
   
       public void test2() {
           lock.lock();
           try {
               System.out.println(Thread.currentThread().getName());
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               lock.unlock();
           }
       }
   
       public static void main(String[] args) {
           LockTest lockTest = new LockTest();
           for (int i = 0; i < 5; i++) {
               new Thread(() -> {
                   lockTest.test();
               }, "T" + i).start();
           }
       }
   
       /**
        * 运行结果表明：同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁
        * 即递归锁
        */
   }
   

   运行结果：
   
   运行结果表明：内层方法虽然加锁了，但是并不需要再竞争锁资源，即
   同一个线程获取到外层方法的锁后，会自动获取到内层方法的锁，即递归锁