实现一个独占锁

本文主要是基于AQS实现一个简单的独占锁
以下是实现的锁代码，
1、创建MySynLock 类实现Lock接口，实现接口方法，实现接口的方法，其中主要方法：
2、继承AbstractQueuedSynchronizer抽象类，重写其中的模板方法
我们查看AbstractQueuedSynchronizer的释放锁的方法

public class MySynLock  implements Lock {

    public class  Syn  extends AbstractQueuedSynchronizer{
        public Condition conditionObject=new ConditionObject();
        /**
         * 获取锁🔒
         * @param arg
         * @return
         */
        @Override
        protected boolean tryAcquire(int arg) {
            if(compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        /**
         * 释放锁🔒
         * @param arg
         * @return
         */
        @Override
        protected boolean tryRelease(int arg) {
            if (getState()==0){
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        /**
         * 判断锁🔒是否被占用
         * @return
         */
        @Override
        protected boolean isHeldExclusively() {
            return getState()==1;
        }
    }

    private  final  Syn syn=new Syn();
    @Override
    public void lock() {
        System.out.println(Thread.currentThread().getName()+"正在获取锁");
        syn.acquire(1);
        System.out.println(Thread.currentThread().getName()+"获取锁成功");
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
         syn.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return syn.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        System.out.println(Thread.currentThread().getName()+"正在释放锁");
        syn.release(1);
        System.out.println(Thread.currentThread().getName()+"释放锁成功");
    }

    /**
     * 锁是否备注占用
     * @return
     */
   public  boolean   isLocked(){
        return syn.isHeldExclusively();
   }

    @Override
    public Condition newCondition() {
        return syn.conditionObject;
    }
}

下面是测试方法：

public class Test {
    final Lock lock=new MySynLock();
  public  void test(){
      class  Work extends  Thread{
          @Override
          public void run() {
              lock.lock();
              System.out.println(Thread.currentThread().getName());
              try {
                  Thread.sleep(1);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }finally {
                  lock.unlock();
              }
          }

      }
      for (int i = 0; i <4; i++) {
          new Work().start();
      }
  }
  public static void main(String[] args) {
        Test test = new Test();
        test.test();
    }
}

测试结果：