实现属于自己的锁

• 实现lock接口
• 使用wait notify

• import java.util.concurrent.TimeUnit;
  import java.util.concurrent.locks.Condition;
  import java.util.concurrent.locks.Lock;
  
  public class MyLock implements Lock {
  
      private boolean isHoldLock = false;
  
      private Thread holdLockThread = null;
  
      private int reentryCount = 0;
  
      /**
       * 同一时刻，能且仅能有一个线程获取到锁，
       * 其他线程，只能等待该线程释放锁之后才能获取到锁
       */
      @Override
      public synchronized void lock() {
          if (isHoldLock && Thread.currentThread() != holdLockThread) {
              try {
                  wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          holdLockThread = Thread.currentThread();
          isHoldLock = true;
          reentryCount++;
      }
  
      @Override
      public synchronized void unlock() {
          //判断当前线程是否是持有锁的线程，是，重入次数减去1，不是就不做处理
          if (Thread.currentThread() == holdLockThread) {
              reentryCount--;
              if (reentryCount == 0) {
                  notify();
                  isHoldLock = false;
              }
          }
      }
  
      @Override
      public Condition newCondition() {
          return null;
      }
  
      @Override
      public void lockInterruptibly() throws InterruptedException {
  
      }
  
      @Override
      public boolean tryLock() {
          return false;
      }
  
      @Override
      public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
          return false;
      }
  }

• import java.util.concurrent.locks.Lock;
  
  /**
   * 重入Demo
   */
  public class ReentryDemo {
  
      public Lock lock = new MyLock();
  
      public void methodA() {
          lock.lock();
          System.out.println("进入方法A");
          methodB();
          lock.unlock();
      }
  
      public void methodB() {
          lock.lock();
          System.out.println("进入方法B");
          lock.unlock();
      }
  
  
      public static void main(String[] args) {
          ReentryDemo reentryDemo = new ReentryDemo();
          reentryDemo.methodA();
      }
  
  }
  

• public class UnSafeThread {
      private static int num = 0;
  
      private static Lock lock = new ReentrantLock();
  
      private static CountDownLatch countDownLatch = new CountDownLatch(10);
  
      public static void main(String[] args){
          for(int i=0;i<10;i++){
              new Thread(() ->{
                  for(int j=0;j<1000;j++){
                      inCreate();
                  }
                  //每个线程执行完成之后，调用countdownLatch
                  countDownLatch.countDown();
              }).start();
          }
      }
  
      public static void inCreate(){
          lock.lock();
          num++;
          lock.unlock();
      }
  
  }