主要针对AQS原理进行巩固，利用自定义的同步器实现不可重入锁

自定义锁

部分方法直接使用父类的同步器实现的

  1. public class NonReentrantLock implements Lock {
  2.     private final NonReentrantSync sync = new NonReentrantSync();
  4.     // 尝试，不成功，进入等待队列
  5.     @Override
  6.     public void lock() {
  7.         sync.acquire(1);
  8.     }
  10.     // 尝试，不成功，进入等待队列，可打断
  11.     @Override
  12.     public void lockInterruptibly() throws InterruptedException {
  13.         sync.acquireSharedInterruptibly(1);
  14.     }
  16.     //尝试一次，不成功返回，不进入队列
  17.     @Override
  18.     public boolean tryLock() {
  19.         return sync.tryAcquire(1);
  20.     }
  22.     /**
  23.      * @throws
  24.      * @description 尝试，不成功，进入等待队列，有时限
  25.      * @author SongHongWei
  26.      * @params
  27.      * @updateTime 2021/10/5 12:21
  28.      */
  29.     @Override
  30.     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
  31.         return sync.tryAcquireSharedNanos(1, unit.toNanos(time));
  32.     }
  34.     //释放锁
  35.     @Override
  36.     public void unlock() {
  37.         sync.release(1);
  38.     }
  40.     //生成条件变量
  41.     @Override
  42.     public Condition newCondition() {
  43.         return sync.newCondition();
  44.     }
  45. }

自定义同步器

只是实现了独占锁的实现方法

  1. public class NonReentrantSync extends AbstractQueuedSynchronizer {
  3.     protected Condition newCondition() {
  4.         return new ConditionObject();
  5.     }
  7.     /**
  8.      * @throws
  9.      * @description 尝试获取资源，立即返回。成功则返回true，否则false。
  10.      * @author SongHongWei
  11.      * @params
  12.      * @updateTime 2021/10/5 12:14
  13.      */
  14.     @Override
  15.     protected boolean tryAcquire(int arg) {
  16.         // 这里限定只能为1个量
  17.         if (arg == 1) {
  18.             //state为0才设置为1，不可重入
  19.             if (compareAndSetState(0, 1)) {
  20.                 //设置为当前线程独占资源
  21.                 setExclusiveOwnerThread(Thread.currentThread());
  22.                 return true;
  23.             }
  24.         }
  25.         return false;
  26.     }
  28.     /**
  29.      * @throws
  30.      * @description  尝试释放资源，立即返回。成功则为true，否则false。
  31.      * @author SongHongWei
  32.      * @params
  33.      * @updateTime 2021/10/5 12:17
  34.      */
  35.     @Override
  36.     protected boolean tryRelease(int arg) {
  37.         //限定为1个量
  38.         if(arg == 1) {
  39.             ///既然来释放，那肯定就是已占有状态了。只是为了保险，多层判断
  40.             if(getState() == 0) {
  41.                 throw new IllegalMonitorStateException();
  42.             }
  43.             setExclusiveOwnerThread(null);
  44.             //释放资源，放弃占有状态
  45.             setState(0);
  46.             return true;
  47.         }
  48.         return false;
  49.     }
  51.     @Override
  52.     protected boolean isHeldExclusively() {
  53.         return getState() == 1;
  54.     }

测试类

测试结果，t1线程始终获取不到第二次锁

  1. public class AqsClient {
  3.     static final NonReentrantLock lock = new NonReentrantLock();
  5.     public static void main(String[] args) {
  6.         log.info("主线程启动....");
  7.         new Thread(() -> {
  8.             lock.lock();
  9.             log.info("线程t1第一次获取锁...");
  10.             try {
  11.                 log.info("线程t1尝试再次获取锁...");
  12.                 lock.lock();
  13.                 log.info("线程t1再次获取锁成功");
  14.                 lock.unlock();
  15.                 log.info("线程t1释放重入锁...");
  16.             } finally {
  17.                 lock.unlock();
  18.                 log.info("线程t1释放锁");
  19.             }
  20.         }, "t1").start();
  22.     }
  23. }