设计模式-模板方法模式

模板方法模式的优势是可以在设计时就确定算法的执行流程（往往是不可变的），以到达把控整体执行流程的目的，具体实现细节延迟到子类完成，不用关心（即行为由父类控制，子类实现）；也可以用来在重构时，抽取子类的共同逻辑。

模板方法模式简单描述

模板方法模式主要是成员有：

• 基本方法：又叫基本操作，是由子类实现的方法，并且在模板方法中被调用
• 模板方法： 可以有多个，一般是一个具体的方法，也就是一个框架，实现对基本方法的调用，完成固定的逻辑，某些情况下为防止恶意修改框架可以是final的。
• 钩子方法：控制执行的流程。

AQS中的模板方法模式

AQS是jdk提供的一个抽象队列同步器，主要实现了同步机制的框架，具体细节交由子类实现，jdk中有很多api运用到了这个同步器，比如：ThreadPoolExecutor，ReentrantLock，ReentrantReadWriteLock，CountDownLatch，Semaphore。
为了说明，手写lock，以体验模板方法模式在AQS中的应用。

简单实现自己的Lock

MyLock.java

public class MyLock {
    private final Sync sync;

    private class Sync extends AbstractQueuedSynchronizer {
        /**
         * 将状态改为一
         *
         * @param arg
         * @return
         */
        @Override
        protected boolean tryAcquire(int arg) {
            assert arg == 1;
            if (compareAndSetState(0, arg)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            assert arg == 0;
            if (getState() == 1 && getExclusiveOwnerThread() != Thread.currentThread()) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(arg);
            return true;
        }

        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

    }

    public MyLock() {
        sync = new Sync();
    }

    public void lock() {
        sync.acquire(1);
    }

    public Boolean unLock() {
        return sync.release(0);
    }

    public static void main(String[] args) {
        final MyLock lock = new MyLock();
        new Thread(new Runnable() {
            public void run() {
                System.out.println("执行当前线程" + Thread.currentThread().getName());
                lock.lock();
                System.out.println("当前线程" + Thread.currentThread().getName() + "获取锁");
                try {
                    //dobiz
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    if (lock.unLock()) {
                        System.out.println("当前线程" + Thread.currentThread().getName() + "释放了锁");
                    }
                }
            }
        }, "thread1").start();
        new Thread(new Runnable() {
            public void run() {
                System.out.println("执行当前线程" + Thread.currentThread().getName());
                lock.lock();
                System.out.println("当前线程" + Thread.currentThread().getName() + "获取锁");
                try {
                    //dobiz
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    if (lock.unLock()) {
                        System.out.println("当前线程" + Thread.currentThread().getName() + "释放了锁");
                    }
                }
            }
        }, "thread2").start();
    }
}

执行结果

我们只需简单的覆写AQS的tryAcquire&tryRelease，具体使用锁的场景，调用AQS的acquire&release就能实现类似ReentrantLock的强大功能（没实现重入），这正式模板方法的魅力所在。

Lock是如何运用模板方法模式

AQS对获取资源（共享或独占）和释放资源提供统一的处理算法，如对获取独占资源封装的算法如下：

其中tryAcquire就是需要我们实现的部分，算法大概的流程是：

• （tryAcquire）尝试更新一次状态值，如果更新成功，则短路返回
• （addWaiter）将当前线程封装成Node数据结构尝试加入一次同步队列，成功则返回node
• （addWaiter）并发入队失败，则自旋入队（enq）
• （acquireQueued）入队成功后，如果入队的节点的前驱是头结点，那么尝试更新一次状态值，更新成功则将当前节点设为头结点（头结点的前驱和所属线程均为null），然后直接返回
• （acquireQueued）本次尝试再次失败后，则判断当前线程是否需要挂起，如果满足挂起条件，则park（LockSupport支持）当前线程，否则自旋更新状态值

对释放独占资源的算法封装如下：

其中tryRelease就是需要我们实现的部分，释放的逻辑比较简单清晰，如果执行tryRelease失败，则直接失败，如果成功，那么unpark Head节点的后继。

通过上诉分析，简单的了解了下模板方法模式在AQS体系中的应用。AQS推荐以内部类继承的方式使用，以到达解耦的目的，因为某些场景中，调用方并不需要关注是谁在提供具体的服务，只需通过Facade便可完成功能。

AQS“实践者”：ReentrantLock

ReentrantLock通过覆写AbstractQueuedSynchronizer的tryRelease()和tryAcquire()实现独占锁，具有重入的功能。
ReentrantLock的简单时序图：