Java Lock 与 队列同步器

public class LockTestDemo implements Lock {

    /**
     * 队列同步器:
     * 队列同步器是构成锁或者其他同步组件的基础框架
     * 同步器主要使用方式是继承,子类通过继承同步器并实现它的抽象方法来管理同步状态
     *
     * 同步器提供三个改变同步状态的方法，能够保证状态的改变是安全的
     * getState()   //获取当前同步状态
     * setState（int newState） //设置当前同步状态
     * compareAndSetState(int expect,int newState);  //使用CAS设置当前状态，该方法能保证状态设置的原子性
     *
     * 同步器自身没有实现任何同步状态接口，同步器仅仅定义了若干同步状态的获取和释放方法供自定义同步组件使用
     * Lock的子类可以叫做同步组件
     *
     * 同步器是实现锁的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义
     * 锁和同步器之间的关系:
     * 锁是面向使用者，所定义了使用者与锁交互的接口，隐藏了实现细节
     * 同步器面向是锁的实现着，他简化了锁的实现方法，屏蔽了同步状态管理，线程的排队、等待与唤醒等底层操作
     *
     * 锁和同步器很好的隔离了使用者与实现着锁关注的领域
     *
     *
     *
     * 同步器的设计是基于模板方法模式:
     * 使用者需要继承同步器并重新指定的方法，随后将同步器组合在自定义同步组件（Lock）的实现中，
     * 同步组件（Lock）调用用同步器提供的模板方法，这些模板方法将会调用使用者重写的方法
     *
     * 同步器提供的模板方法:
     * 同步组件调用以下模板方法实现锁的语义,以下模板方法调用同步器需要用户实现的重新的方法
     *
     *
     * 独占式获取同步状态，如果当前线程获取同步状态成，则由该方法返回，否则将会进入同步队列等待，
     * 该方法调用重写的protected boolean tryAcquire(int arg)
     * public final void acquire(int arg)
     *
     *
     * 与public final void acquire(int arg)相同，但是该方法响应中断，当前线程未获取到同步状态而进入同步队列中
     * 如果当前线程被中断，则该方法会抛出异常并返回
     * public final void acquireInterruptibly(int arg)
     *
     * 在public final void acquireInterruptibly(int arg)基础之上增加超时限制，
     * 如果在当前线程在超时时间内没有获取到同步状态，将会返回false，否则返回true
     * public final boolean tryAcquireNanos(int arg, long nanosTimeout)
     *
     *
     * 共享式获取同步状态，与独享式主要区别是在同一时刻可以多个线程获取到同步状态
     * public final void acquireShared(int arg)
     *
     * 该方法响应中断
     * public final void acquireSharedInterruptibly(int arg)
     *
     * 添加超时响应中断
     * public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
     *
     * 共享式释放同步状态该
     * public final boolean releaseShared(int arg)
     *
     * 独占式释放同步状态
     * public final boolean release(int arg)
     *
     *
     * 获取等待在同步队列上的线程集合
     * public final Collection<Thread> getQueuedThreads()
     *
     */
    class MyQueuedSynchronizer extends AbstractQueuedSynchronizer {

        //        独占式获取同步状态 实现该方法需要查询放钱状态并判断同步状态是否符合预期,然后在进行CAS设置同步状态
        @Override
        protected boolean tryAcquire(int arg) {
            return super.tryAcquire(arg);
        }

        //        独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态
        @Override
        protected boolean tryRelease(int arg) {
            return super.tryRelease(arg);
        }

        //        共享式获取同步状态，返回大于0的值吧，表示获取成功反之回去失败
        @Override
        protected int tryAcquireShared(int arg) {
            return super.tryAcquireShared(arg);
        }

        //        共享释放同步状态
        @Override
        protected boolean tryReleaseShared(int arg) {
            return super.tryReleaseShared(arg);
        }

        //        当前同步器是否在独占模式下线程被占用，一般该方法表示是否被当前线程独占
        @Override
        protected boolean isHeldExclusively() {
            return super.isHeldExclusively();
        }


    }


    //    获取锁,调用该方法当前线程将获取锁,当锁获得后,从该方法返回
    @Override
    public void lock() {

    }

    //    可以中断地获取锁,和lock()方法不同的之处在于该方法会响应中断,即在获的获取中可以中断当前线程
    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    //    尝试非阻塞获取锁,调用该方法立刻返回,如果能够获取锁则返回true,否则返回false
    @Override
    public boolean tryLock() {
        return false;
    }

    /**
     * 超时获取锁,以下三种情况会返回:
     * ① 当前线程在超时时间内获得了锁
     * ② 当前线程在超时时间内被中断
     * ③ 超时时间借宿，返回false
     */
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    //    释放锁
    @Override
    public void unlock() {

    }

    //    获取等待通知组件,该组件和当前锁绑定,当前线程只有获得了锁,才能调用该组件的wait()方法，而调用wait()方法后，当前线程将释放锁
    @Override
    public Condition newCondition() {
        return null;
    }
}