可重入锁

可重入锁：也叫递归锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁

package lock;

/** 
 * 可重入锁：也叫递归锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁
 *
 */
class ReentrantLockDemo {

  public static void main(String[] args) {
    ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
    reentrantLockDemo.methodA();
  }

  // 创建锁
  private ReentrantLock reentrantLock = new ReentrantLock();

  public void methodA() {
    try {
      // 加锁
      reentrantLock.lock();
      methodB();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      // 解锁
      reentrantLock.unlock();
    }
  }

  public void methodB() {
    try {
      // 加锁
      reentrantLock.lock();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      // 解锁
      reentrantLock.unlock();
    }
  }
}

class ReentrantLock {

  // 是否上锁
  private boolean isLock = false;

  // 上锁次数
  private int lockCount = 0;

  // 上锁的线程
  private Thread lockThread = null;

  public synchronized void lock() throws InterruptedException {
    System.out.println("进入lock上锁方法");

    // 上锁 且 上锁线程不是当前线程 进入阻塞状态
    while (isLock && lockThread != Thread.currentThread()) {
      // 进入等待状态
      wait();
    }
    // 上锁
    isLock = true;
    // 获取当前线程
    lockThread = Thread.currentThread();
    // 锁数量加1
    lockCount++;
  }

  public synchronized void unlock() {
    System.out.println("进入unlock解锁方法");

    // 判断上锁线程 是否为当前线程
    if (lockThread == Thread.currentThread()) {
      // 只有当锁的数量为0了才算解锁完毕
      if (lockCount == 0) {
        // 解锁
        isLock = false;
        // 将对象释放
        lockThread = null;
        // 唤醒线程
        notify();
      }
      // 每次解锁数量-1
      lockCount--;
    }
  }
}