jdk遇到设计模式之模板方法

突然想写一个系列，记录在jdk中使用的设计模式。

1、jdk中有很多用到模板方法的地方，比如众所周知的当类comparable接口后可以用Collections.sort （和 Arrays.sort ）。其实这就是一个经典的模板方法。

2、今天想详细的叙述另一个jdk中经典的模板方法的应用类AQS(AbstractQueuedSynchronizer)，这是在java并发包中非常重要的一个类，比如ReetrantLock，ReadWriteLock等很多同步工具都是基于此类实现。甚至连jdk1.6之前的FutureTask都是基于此实现。（当然，由于通用和专用的天然矛盾，比如StampedLock就没有继承该抽象类）

根据记忆AQS有5个抽象方法（可能有误）需要子类去实现，

isHeldExclusively()：该方法将返回同步对于当前线程是否是独占的（一般Condition需要去实现）
tryAcquire(int)：独占方式。尝试获取资源。
tryRelease(int)：独占方式。尝试释放资源。
tryAcquireShared(int)：共享方式。尝试获取资源。
tryReleaseShared(int)：共享方式。尝试释放资源。

今天的重点是模板方法，所以我们以tryAcquire(int)为例子来看看是AQS是如何应用模板方法的。

    /**     * Acquires in exclusive mode, ignoring interrupts.  Implemented     * by invoking at least once {@link #tryAcquire},     * returning on success.  Otherwise the thread is queued, possibly     * repeatedly blocking and unblocking, invoking {@link     * #tryAcquire} until success.  This method can be used     * to implement method {@link Lock#lock}.     *     * @param arg the acquire argument.  This value is conveyed to     *        {@link #tryAcquire} but is otherwise uninterpreted and     *        can represent anything you like.     */    public final void acquire(int arg) {        if (!tryAcquire(arg) &&            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))            selfInterrupt();    }

在acquire方法中我们看到了调用tryAcquire,上面这段代码的大意是。

先尝试tryAcquire获取资源，失败的话

1、将当前等待线程包装成一个等待节点加入等待队列（addWaiter（）方法）

2、从队列中尝试获取临界资源(acquireQueued()方法)

接下来看看addWaiter方法的实现

    /**     * Creates and enqueues node for current thread and given mode.     *     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared     * @return the new node     */    private Node addWaiter(Node mode) {        Node node = new Node(Thread.currentThread(), mode);        // Try the fast path of enq; backup to full enq on failure        Node pred = tail;        if (pred != null) {            node.prev = pred;            if (compareAndSetTail(pred, node)) {                pred.next = node;                return node;            }        }        enq(node);        return node;    }

    /**     * Inserts node into queue, initializing if necessary. See picture above.     * @param node the node to insert     * @return node's predecessor     */    private Node enq(final Node node) {        for (;;) {            Node t = tail;            if (t == null) { // Must initialize                if (compareAndSetHead(new Node()))                    tail = head;            } else {                node.prev = t;                if (compareAndSetTail(t, node)) {                    t.next = node;                    return t;                }            }        }    }

试着把上面两个方法连起来看。

在addWaiter中先获取等待队列的尾节点，并且尝试设置新的尾节点。

cas失败或者tail是null的情况下，调用enq方法。
enq方法很简单，源码扫一眼就知道了。

通过上面的讲述，我们已经知道了addWaiter方法的实现。就是将等待节点插入等待队列中。

那么接下来看acquireQueued方法。

    /**     * Acquires in exclusive uninterruptible mode for thread already in     * queue. Used by condition wait methods as well as acquire.     *     * @param node the node     * @param arg the acquire argument     * @return {@code true} if interrupted while waiting     */

    final boolean acquireQueued(final Node node, int arg) {        boolean failed = true;        try {            boolean interrupted = false;            for (;;) {                final Node p = node.predecessor();                if (p == head && tryAcquire(arg)) {                    setHead(node);                    p.next = null; // help GC                    failed = false;                    return interrupted;                }                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    interrupted = true;            }        } finally {            if (failed)                cancelAcquire(node);        }    }

在循环中主要做了这些事情：

1、找到当前节点的前任节点

2、前任节点是头节点、并且tryAcquire成功

3、把自己设置成头节点
4、前任节点不是头节点

5、睡、或者不睡这个取决于约定的时间(acquire(time))

6、睡得时候顺便检查一下是否被打断了

finally中主要是failed就取消Acquire。

最后看一下cancelAcquire方法吧

    /**     * Cancels an ongoing attempt to acquire.     *     * @param node the node     */    private void cancelAcquire(Node node) {        //node为空        if (node == null)            return;

//将thread设置null

        node.thread = null;        // Skip cancelled predecessors        Node pred = node.prev;        while (pred.waitStatus > 0)            node.prev = pred = pred.prev;        // predNext is the apparent node to unsplice. CASes below will        // fail if not, in which case, we lost race vs another cancel        // or signal, so no further action is necessary.        Node predNext = pred.next;        // Can use unconditional write instead of CAS here.        // After this atomic step, other Nodes can skip past us.        // Before, we are free of interference from other threads.        node.waitStatus = Node.CANCELLED;        // If we are the tail, remove ourselves.        if (node == tail && compareAndSetTail(node, pred)) {            compareAndSetNext(pred, predNext, null);        } else {            // If successor needs signal, try to set pred's next-link            // so it will get one. Otherwise wake it up to propagate.            int ws;            if (pred != head &&                ((ws = pred.waitStatus) == Node.SIGNAL ||                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&                pred.thread != null) {                Node next = node.next;                if (next != null && next.waitStatus <= 0)                    compareAndSetNext(pred, predNext, next);            } else {                unparkSuccessor(node);            }            node.next = node; // help GC        }    }

这个douglea的注释已经很详尽了。

最后简单总结一下。按照个人的理解。模板方法就是在一个流程从具体的某一步骤需要由具体的情况决定。但是其他的步骤都是一致的。

所以可以定义抽象父类实现通用的步骤，由子类去实现专用的步骤。