模板模式由一个抽象类和一个实现类组成，抽象类中主要有三类方法：
模板方法：实现了算法主体框架，供外部调用。里面会调用原语操作和钩子操作。
原语操作：即定义的抽象方法，子类必须重写。
钩子操作：和原语操作类似，也是供子类重写的，区别是钩子操作子类可以选择重写也可以选择不重写，如果不重写则使用抽象类默认操作，通常是一个空操作或抛出异常。

package com.gome;

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 MutexLock implements Lock{
    private MutexSynchronizer synchronizer=new MutexSynchronizer();
    
    private static class MutexSynchronizer extends AbstractQueuedSynchronizer{
        /**
         * @param unused 这个参数是用来传同步状态的累加值的，因为我们实现的是独占锁，
         * 因此这个参数实际用不到，我们在方法里累加值恒为1
         */
        @Override
        protected boolean tryAcquire(int unused) {
            /**
             * 用CAS来更新AQS的同步状态，如果原值是0则更新为1代表已经有线程获取了独占锁
             */
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread()); //设置当前独占锁的所有者线程
                return true;
            }
            return false;
        }
        
        /**
         * @param unused 这个参数是用来传同步状态的递减值的，因为我们实现的是独占锁，
         * 因此这个参数实际用不到，我们在方法里递减值恒为1
         */
        @Override
        protected boolean tryRelease(int unused) {
            //如果当前AQS同步状态是0，说明试图在没有线程获得同步状态的情况下释放同步状态，直接抛异常
            if (getState()==0)
                throw new IllegalMonitorStateException();
            
            //这里不需要CAS而是直接把同步状态设置为0，因为我们实现的是独占锁，正常情况下会执行释放操作的线程只有同步状态的所有者线程
            setState(0);
            setExclusiveOwnerThread(null);
            return true;
        }
        
        protected Condition newCondition() {
            return new ConditionObject();
        }
    }

    @Override
    public void lock() {
        synchronizer.acquire(1);
    }

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

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

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return synchronizer.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        synchronizer.release(1);
    }

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