掌握设计模式--模板方法模式

模板方法模式（Template Method Pattern）

模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个操作中的算法骨架，并允许子类在不改变算法结构的情况下重新定义算法的某些步骤。

核心思想：模板方法定义算法骨架，浅白地说，定义通用的逻辑框架、控制流程和调用顺序，而具体的实现将延迟到子类，从而在不改变结构的前提下扩展算法的灵活性。再简单点说：定义了一个处理逻辑的步骤（一个骨架），具体的处理逻辑由子类继承后实现（真正的血肉）。

主要组成部分

抽象类（AbstractClass）：

定义模板方法，模板方法包含算法的骨架。
实现一些不变的步骤，或声明需要子类实现的抽象方法。

具体类（ConcreteClass）：

实现抽象类中声明的抽象方法，从而完成算法的具体步骤。

案例实现

实现一个简单的自定义锁，展示如何利用模板方法模式来定义锁的行为。

案例类图

定义抽象类 `AbstractLock`

AbstractLock 提供了模板方法（lock 和 unlock），而具体的处理逻辑是获取锁和释放锁 方法tryAcquire 和 tryRelease，这两个方法的具体实现交由子类完成。

java 复制代码

// 抽象类定义锁的框架
public abstract class AbstractLock {
    // 模板方法：锁的流程固定
    public final void lock() {
        if (!tryAcquire()) { // 尝试获取锁
            waitForLock();   // 获取失败时等待
        }
    }

    // 模板方法：解锁的流程固定
    public final void unlock() {
        if (tryRelease()) { // 尝试释放锁
            notifyWaitingThreads(); // 唤醒等待的线程
        }
    }

    // 钩子方法：尝试获取锁（子类实现）
    protected abstract boolean tryAcquire();

    // 钩子方法：尝试释放锁（子类实现）
    protected abstract boolean tryRelease();

    // 默认行为：等待获取锁（可以覆盖）
    protected void waitForLock() {
        try {
            synchronized (this) {
                wait(); // 阻塞线程
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // 默认行为：通知等待线程（可以覆盖）
    protected void notifyWaitingThreads() {
        synchronized (this) {
            notifyAll(); // 唤醒所有等待线程
        }
    }
}

实现具体的锁 `SimpleLock`

SimpleLock 继承了 AbstractLock，并实现了具体的锁逻辑：

java 复制代码

public class SimpleLock extends AbstractLock {
    private boolean isLocked = false; // 锁状态
    private Thread lockingThread = null; // 持有锁的线程

    @Override
    protected synchronized boolean tryAcquire() {
        if (!isLocked) {
            isLocked = true;
            lockingThread = Thread.currentThread();
            return true;
        }
        return false;
    }

    @Override
    protected synchronized boolean tryRelease() {
        if (Thread.currentThread() == lockingThread) {
            isLocked = false;
            lockingThread = null;
            return true;
        }
        return false;
    }
}

测试 `SimpleLock`

通过多线程模拟锁的使用场景

java 复制代码

public class TemplateLockExample {
    public static void main(String[] args) {
        SimpleLock lock = new SimpleLock();

        Runnable task = () -> {
            lock.lock(); // 获取锁
            try {
                System.out.println(Thread.currentThread().getName() + " acquired the lock");
                Thread.sleep(1000); // 模拟任务执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + " released the lock");
                lock.unlock(); // 释放锁
            }
        };

        // 启动多个线程测试锁的互斥
        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");
        Thread t3 = new Thread(task, "Thread-3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果

复制代码

Thread-1 获得锁
Thread-1 释放锁
Thread-3 获得锁
Thread-2 获得锁
Thread-2 释放锁
Thread-3 释放锁

注：该案例并未正确实现完整的锁机制，仅仅为了讲述模版方法模式。

分析

模板方法的作用 ：lock 和 unlock 方法在 AbstractLock 中定义了锁的固定流程，子类只需实现具体的 tryAcquire 和 tryRelease 方法即可。
扩展性 ：可以通过继承 AbstractLock 实现不同的锁机制，例如：读写锁、可重入锁、公平锁等。
简化逻辑：模板方法模式将通用逻辑集中在抽象类中，避免子类重复实现。

优缺点和应用场景

优点

提高代码复用性，通用代码在父类中实现。
提供扩展灵活性，通过子类覆盖实现具体步骤。
符合开闭原则，增加新功能时无需修改模板方法。

缺点

每个具体实现都需要定义子类，导致类数量增加。
对算法步骤的控制较为严格，可能不适合所有场景。

应用场景

多个类的逻辑相同但细节不同：公共部分代码抽取到父类，具体实现由子类提供。
避免代码重复：在模板方法中实现通用逻辑，特定逻辑由子类实现。
固定框架：需要确保子类遵循算法的基本结构。

模板方法模式的应用

Java中锁的实现（模版类AbstractQueuedSynchronizer，简称AQS），子类（如ReentrantLock、ReentrantReadWriteLock等）通过继承AQS并实现其抽象方法（如tryAcquire、tryRelease等）来完成具体的同步逻辑；
Java Swing 中的框架设计（例如 paint() 方法是一个模板方法）；
JUnit 中的测试框架（测试用例继承 TestCase 并重写具体方法）。