独占锁Mutex的一个自定义同步组件案例以及同步器API

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

/**
 * 独占锁Mutex是一个自定义同步组件，它在同一时刻只允许一个线程占有锁，
 * 其中定义了一个静态内部类，该内部类继承了同步器并实现了独占式获取和
 * 释放同步状态。在tryAcquire(int acquires)方法中，若经过CAS设置成功
 * (同步状态设置为1),则代表获取了同步状态，而在tryRelease(int releases)
 * 中将同步状态设置为0.
 * 用户在使用Mutex时并不会直接和内部同步器的实现打交道，而是调用Mutex提供的方法，
 * 在Mutex实现中以获取锁的lock()方法为例，只需要在方法实现中调用同步器的模板方法
 * acquire(int args)即可，当前线程调用该方法获取同步状态失败后被加入到同步队列中等待，
 * 这样就大大的降低了实现一个可靠自定义同步组件的门槛。
 */

public class Mutex implements Lock {
    /*
     *同步器的API
     * 重写方法
     *  getState()  获取当前同步状态
     *  setState(int newState)  设置当前同步状态
     *  compareAndSetState(int expect,int update)   使用CAS设置当前状态，该方法能够保证状态设置的原子性。
     *  tryAcquire(int arg) 独占式获取同步状态，实现该方法需要查询当前状态并判断同步状态是否符合预期，然后再进行CAS设置同步状态
     *  tryRelease(int arg) 独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态
     *  tryAcquireShared(int arg) 共享式获取同步状态，返回大于等于0的值，表示获取成功，反之获取失败
     *  tryReleaseShared(int arg)   共享式释放同步状态
     *  isHeldExclusively()     当前同步器是否在独占模式下被线程占用，一般该方法表示是否被当前线程所独占
     *
     *  同步器提供的模板方法
     *  acquire(int arg)    独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则
     *                      将会进入同步队列等待，该方法将会调用重写的tryAcquire(int arg)方法
     *  acquireInterruptibly(int arg)   与acquire(int arg)相同，但是该方法响应中断，当前线程未获取到
     *                                  同步状态而进入同步队列种，如果当前线程被中断，则该方法会抛出InterruptedException异常并返回
     *  tryAcquireNanos(int arg,long nanos)     在acquireInterruptibly(int arg)基础上增加了超时限制，若当前线程在超时
     *                                          时间内没有获取到同步状态，那么将会返回false，若获取到了返回true。
     *  acquireShared(int arg)  共享式获取同步状态， 若当前线程为获取到同步状态，将会进入同步队列等待，与独占式获取的
     *                          主要区别是在同一时刻可以由多个线程获取到同步状态
     *  acquireSharedInterruptibly(int arg)   与acquireShared(int arg)相同，该方法响应中断
     *  tryAcquireSharedNanos(int arg,long nanos)   在acquireSharedInterruptibly(int arg)基础上增加了超时限制
     *  release(int arg)        独占式的释放同步状态，该方法会在释放同步状态后，将同步队列中第一个节点包含的线程唤醒
     *  releaseShared(int arg)  共享式的释放同步状态
     *  Collection<Thread> getQueueThreads()    获取等待在同步队列上的线程集合
     *
     */


    //静态内部类，自定义同步器
    private static class Sync extends AbstractQueuedSynchronizer{
        //是否处于占用状态
        protected boolean isHeldExclusively(){
            return getState()==1;
        }
        //当状态为0时获取锁
        public boolean tryAcquire(int acquires){
            if (compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        //释放锁，将状态设置为0
        protected boolean tryRelease(int releases){
            if (getState()==0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        //返回一个Condition,每个condition都包含了一个condition队列
        Condition newCondition(){
            return new ConditionObject();
        }
    }

    //仅需要将操作代理到Sync上即可
    private final Sync sync=new Sync();
    public void lock(){
        sync.acquire(1);
    }

    public  boolean isLocked(){
        return  sync.isHeldExclusively();
    }
    public boolean hasQueueThreads(){
        return sync.hasQueuedThreads();
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

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

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

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

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


}