Juc07_乐观锁和悲观锁、公平锁和非公平锁、递归锁(可重入锁)、死锁及排查、自旋锁（二）

2022-01-06 202

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： ③. 可重入锁(又名递归锁)

③. 可重入锁(又名递归锁)

①. 什么是可重入锁？

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

如果是1个有synchronized修饰得递归调用方法,程序第2次进入被自己阻塞了岂不是天大的笑话,出现了作茧自缚

所以Java中ReentrantLock和Synchronized都是可重入锁,可重入锁的一个优点是可在一定程度避免死锁

②. 可重入锁这四个字分开解释

可: 可以 | 重: 再次 | 入: 进入 | 锁: 同步锁 | 进入什么:进入同步域(即同步代码块、方法或显示锁锁定的代码)

③. 代码验证synchronized和ReentrantLock是可重入锁

//synchronized 是可重入锁
class Phone{
    public synchronized void sendSms() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\tsendSms");
        sendEmail();
    }
    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\tsendEmail");
    }
}
/**
 * Description:
 *  可重入锁(也叫做递归锁)
 *  指的是同一先生外层函数获得锁后,内层敌对函数任然能获取该锁的代码
 *  在同一线程外外层方法获取锁的时候,在进入内层方法会自动获取锁
 *  *  也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块
 *  **/
public class ReenterLockDemo {
    /**
     * t1 sendSms
     * t1 sendEmail
     * t2 sendSms
     * t2 sendEmail
     * @param args
     */
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendSms();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t1").start();
        new Thread(()->{
            try {
                phone.sendSms();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

//ReentrantLock 是可重入锁
  class Phone implements Runnable {
      private Lock lock = new ReentrantLock();
      @Override
      public void run() {
          get();
      }
      private void get() {
          lock.lock();
          try {
              System.out.println(Thread.currentThread().getName() + "\tget");
              set();
          } finally {
              lock.unlock();
          }
      }
      private void set() {
          lock.lock();
          try {
              System.out.println(Thread.currentThread().getName() + "\tset");
          } finally {
              lock.unlock();
          }
      }
  }
  /**
   * Description:
   * 可重入锁(也叫做递归锁)
   * 指的是同一先生外层函数获得锁后,内层敌对函数任然能获取该锁的代码
   * 在同一线程外外层方法获取锁的时候,在进入内层方法会自动获取锁
   * <p>
   * 也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块
   **/
  public class ReenterLockDemo {
      /**
       * Thread-0 get
       * Thread-0 set
       * Thread-1 get
       * Thread-1 set
       */
      public static void main(String[] args) {
          Phone phone = new Phone();
          Thread t3 = new Thread(phone);
          Thread t4 = new Thread(phone);
          t3.start();
          t4.start();
      }
  }