自定义独占锁同步器

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自定义内部同步器时,推荐使用静态内部类
 */
public class CustomThreadLock implements Lock{
    //静态内部类,自定义同步器
     static class Sync extends AbstractQueuedSynchronizer{

        //是否处于占用状态
         public boolean isHeldExclusively() {
              return getState() == 1;
         }

        //当状态为0时获取锁
         public boolean tryAcquire(int arg) {
             //CAS设置状态,能保证操作的原子性    当前为状态为0,操作成功状态改为1
              if(compareAndSetState(0, 1)){
                  //设置当前独占的线程
                  setExclusiveOwnerThread(Thread.currentThread());
                  return true;
              }
              return false;
         }

         //当状态为0时释放锁
        public boolean tryRelease(int arg) {
              //如果同步器同步器状态不为0,则抛出监视器非法状态异常
              if(getState() != 1)
                  throw new IllegalMonitorStateException();
              //设置独占锁的线程为null
              setExclusiveOwnerThread(null);
              //设置同步状态为0
              setState(0);
              return true;
        }

        //返回Condition,每个Condition都包含了一个Condition队列
         Condition newCondition(){
            return new ConditionObject(); 
        }
    }

    //将操作代理到Sync上
    private final Sync sync = new Sync();

    public void lock() {
        //独占式获取同步状态,获取失败将会进入同步队列等待,并且调用自定义的tryAcquire方法
        sync.acquire(1);
    }

    //尝试获取锁,如果成功返回true,否则为false
    public boolean tryLock() {
        //调用自定义重写的方法
        return sync.tryAcquire(1);
    }

    /*
     * 尝试超时获取锁   超时时间内获取锁,返回true;否则返回false
     * 超时获取锁失败后会加入同步队列等待,并且会进行节点自旋获取锁操作
     */
    public boolean tryLock(long time, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }

    //可中断获取锁
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }


    //释放锁
    public void unlock() {
        sync.release(1);
    }

    public Condition newCondition() {
        return sync.newCondition();
    }

    //判断当前线程是否处于占用状态
    public boolean isLock(){
        return sync.isHeldExclusively();
    }

    //查询是否有任何线程等待获取
     public  boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

}