设计模式之策略模式

一、策略模式概述

　　策略模式（Strategy）：定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的调用者。

二、策略模式解析

　　策略模式是一种定义一系列算法的方法，从概念上看，所有的算法完成的都是相同的工作，只是实现不同，策略模式可以用相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

　　策略模式的Strategy类层次结构为Context（上下文）定义了一系列可供重用的算法或行为，继承有助于析取出这些算法的公共功能。

三、策略模式UML类图

 

四、代码示例

　　没有代码的陪衬就好像在耍流氓，下面来看策略模式的代码示例。

场景：

　　就拿去公司上班的场景为例，我们上班必须要去公司，这个目的地是固定的。员工怎么去到公司呢，根据实际场景，住的离公司近的同事，可以选择步行或者骑车，住的远的可能会选择自驾，出行的方式由员工而定。下面我们用代码来实现这一场景。

4.1、将出行方式抽象

/**
 *     出行至公司的方式
 */
public interface ITripMode {
    
    public String tripWay();
    
}

4.2、出行方式选择步行

public class WalkStrategy implements ITripMode {
    @Override
    public String tripWay() {
        return "步行至公司";
    }
}

4.3、出行方式选择自驾

public class CarTripStrategy implements ITripMode {
    @Override
    public String tripWay() {
        return "自驾至公司";
    }
}

4.4、出行方式选择骑行

public class BikeStrategy implements ITripMode {
    @Override
    public String tripWay() {
        return "骑行至公司";
    }
}

4.5、持有出行方式（算法）的上下文

public class TripModeContext {

    private ITripMode mode;

    public TripModeContext(ITripMode mode) {
        this.mode = mode;
    }
    
    public String tripWay() {
        return mode.tripWay();
    }
    
}

4.6、测试

public class StrategyTest {
    public static void main(String[] args) {
        ITripMode mode = new CarTripStrategy();
        TripModeContext context = new TripModeContext(mode);
        System.out.println("选择的出行方式是：" + context.tripWay());
    }
}

　　运行结果如下：

　　ITripMode定义了算法的公共接口；BikeStrategy、WalkStrategy、CarStrategy作为具体的算法实现；TripModeContext作为上下文，持有ITripMode的引用，作为算法处理的入口，由此可见，策略模式将具体的算法实现与调用算法的客户端做了解耦，当员工有其他的出行方式时，创建一个类实现ITripMode，不必修改现有代码逻辑，使得系统更容易维护。

五、策略模式在JDK中的应用

线程池中的拒绝策略采用了策略模式，分析如下：

5.1、我们先来看拒绝策略的老大哥RejectedExecutionHandler，老大哥规定了拒绝的算法。

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

5.2、abort小弟实现RejectedExecutionHandler的方式

//ThreadPoolExecutor中的静态内部类
public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

　　abort小弟实现的拒绝策略：一旦指定拒绝策略为AbortPolicy ，任务数量使线程池饱和时，会抛出异常。

5.3、discardOldest小弟实现RejectedExecutionHandler的方式

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

　　discardOldest小弟实现的拒绝策略：当e.getQueue()获取线程的工作队列，因为队列遵循(FIFO)先进先出，所以当任务数量使线程池饱和时，线程池e.getQueue().poll()将队列头的数据移除，即移除工作队列中最老的任务，执行新的任务。

5.4、discard小弟实现RejectedExecutionHandler的方式

public static class DiscardPolicy implements RejectedExecutionHandler {
        public DiscardPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

　

　　discard小弟实现的拒绝策略：这个小弟最懒，什么都不做，直接把任务丢弃了。

5.5、CallerRuns小弟实现RejectedExecutionHandler的方式

public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

　　

　　CallerRunsPolicy 小弟实现的拒绝策略：只要线程池没有关闭的话，则使用调用线程直接运行任务。

5.6、我们再来看看RejectedExecutionHandler 的上下文Context---ThreadPoolExecutor，主要代码如下：

public class ThreadPoolExecutor extends AbstractExecutorService {
......

       /**
     * Handler called when saturated or shutdown in execute.
     */
     // 只有工作队列饱和或者线程关闭时调用拒绝的处理
private volatile RejectedExecutionHandler handler;

......

      /**
     * The default rejected execution handler
     */
     // 线程池默认的拒绝策略
private static final RejectedExecutionHandler defaultHandler =  new AbortPolicy();  

......

 // ThreadPoolExecutor的构造函数，当不指定拒绝策略时，
//会调用默认的拒绝策略
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

......

// ThreadPoolExecutor的构造函数，根据业务场景指定拒绝策略，
// 也可自定义拒绝策略
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

......

// 拒绝策略处理
final void reject(Runnable command) {
        handler.rejectedExecution(command, this);
 }

}

由上面的分析，我们可以做一下对比，

　　RejectedExecutionHandler作为策略模式中Strategy的存在，是对拒绝策略算法的抽象。

　　ThreadPoolExecutor 是作为策略模式中上下文的存在，客户端调用拒绝策略的入口。

本文部分内容摘自《大话设计模式》。