1、概述
策略模式定义了一系列的算法,并将每一个算法封装起来,而且使他们可以相互替换,让算法独立于使用它的客户而独立变化。
实际上不要被晦涩难懂的定义迷惑,其实策略设计模式就是定义一个接口,那么只要实现该接口的类,对这些方法进行实现,那么不同的实现类就完成了不同的算法逻辑,而使用该接口的地方,可以根据需要随意更改实现类,因为它们的接口一样额。
因此策略设计模式有三个角色:
抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口实现。此角色给出所有的具体策略类所需的接口。
具体策略(ConcreteStrategy)角色:包装了相关的算法或行为。
策略上下文(Context)角色:持有一个Strategy的引用。
2、代码示例
首先定一个算法接口。
package com.yefengyu.pattern.strategy; public interface Strategy { String run(); }
其次,编写两个类实现该接口,并对接口方法做简单实现,以示区别。
package com.yefengyu.pattern.strategy; public class ConcreteStrategyOne implements Strategy { @Override public String run() {
//此处只是简单的返回
return "ConcreteStrategy One 实现的算法"; } }
package com.yefengyu.pattern.strategy; public class ConcreteStrategyTwo implements Strategy { @Override public String run() { //此处只是简单的返回 return "ConcreteStrategy Two 实现的算法"; } }
接着编写一个策略上下文角色,它持有Strategy接口。下面的StrategyContext有一个Strategy类型的属性,并且通过构造函数传入(也可以是其它方式)。在StrategyContext中有一个execute方法,该方法我们想象它是很复杂的,在其中某一步使用到了策略算法。
package com.yefengyu.pattern.strategy; public class StrategyContext { private Strategy strategy; public StrategyContext(Strategy strategy) { this.strategy = strategy; } public void execute() { //StrategyContext 的 execute 有许多事情要做 System.out.println("------"); //天啊,终于执行到算法这里了 String result = strategy.run(); System.out.println(result); //后续还有好多操作。。。 System.out.println("======"); } }
编写客户端来演示:
package com.yefengyu.pattern.strategy; public class Client { public static void main(String[] args) { Strategy strategy = new ConcreteStrategyOne(); StrategyContext strategyContext = new StrategyContext(strategy); strategyContext.execute(); strategy = new ConcreteStrategyTwo(); strategyContext = new StrategyContext(strategy); strategyContext.execute(); } }
上面的代码中,StrategyContext通过构造函数传入不同的实现类,即可在其execute方法中调用不同的算法。
3、JDK中的策略设计模式-ThreadPoolExecutor
ThreadPoolExecutor使用方式如下:
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadPoolExecutor.CallerRunsPolicy()); executor.execute(new Runnable() { @Override public void run() { System.out.println("hello ThreadPoolExecutor"); } });
让我找到ThreadPoolExecutor的源码,来看看ThreadPoolExecutor是如何使用策略设计模式的。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; }
注意构造器的最后一个参数和代码的最后一行,可以明白ThreadPoolExecutor有一个RejectedExecutionHandler 类型的成员变量 handler,而构造函数则为其赋值。
线程池一般先new一个对象,然后调用execute(submit方法实际稍有点复杂,主要是对任务进行封装,再调了execute方法)方法执行任务,因此我们看看execute方法的实现。
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } else if (!addWorker(command, false)) reject(command); }
上面的代码中多次调用了reject方法,该方法如下,实际就是调用了RejectedExecutionHandler类型的成员变量handler的方法。
final void reject(Runnable command) { handler.rejectedExecution(command, this); }
查看下RejectedExecutionHandler发现它是一个接口,只有一个方法。
package java.util.concurrent; public interface RejectedExecutionHandler { void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
有了接口,那么实现类在哪里呢?还是在RejectedExecutionHandler中,只是使用了静态内部类的形式:
public static class CallerRunsPolicy implements RejectedExecutionHandler { public CallerRunsPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { r.run(); } } } 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()); } } public static class DiscardPolicy implements RejectedExecutionHandler { public DiscardPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { } } public static class DiscardOldestPolicy implements RejectedExecutionHandler { public DiscardOldestPolicy() { } public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { e.getQueue().poll(); e.execute(r); } } }
经过上面的一系列源码探究,我终于要使出对比大法了。
(a): RejectedExecutionHandler接口中的rejectedExecution就是策略模式中的算法,它叫做拒绝策略:如果线程数量大于等于 maximumPoolSize,且 workQueue 已满,则使用拒绝策略处理新任务。
(b): CallerRunsPolicy 、AbortPolicy 、AbortPolicy 、DiscardOldestPolicy 是拒绝策略算法的具体实现。
(c): ThreadPoolExecutor就是策略的上下文(Context)角色。它持有一个RejectedExecutionHandler的引用,使用构造函数对其赋值,其中有方法execute作为环境上下文的主要入口,从中调用了算法。
(d): 本章节的第一处代码:ThreadPoolExecutor使用方式 ,在使用ThreadPoolExecutor时可以通过传入不同的拒绝策略来到达不同的效果,正是策略模式期望的效果。
4、JDK中的策略设计模式-Thread与Runnable
特别注意:在https://www.cnblogs.com/yefengyu/p/10520531.html文章中,我讲解了Thread是模板设计模式的一种实现,那里前提是使用Thread方式创建线程,而不是使用Runnable方式。
通过上面线程池的对比试验之后,我们现在把模板设计模式往Thread和Runnable身上套。
(a): 策略算法?也就是接口? ---> Runnable接口及其方法run方法。
@FunctionalInterface public interface Runnable { public abstract void run(); }
(b): 算法具体实现? ---> 一般由程序员创建一个类实现Runnable接口,重写run方法。
package com.yefengyu.pattern.strategy; public class MyRunnable implements Runnable { @Override public void run() { System.out.println("hello Runnable "); } }
(c): 策略上下文? ---> Thread类持有Runnable接口,并且通过构造函数传入。start方法中隐式调用了Thread类的run方法。
private Runnable target;
public Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); }
public synchronized void start() { if (threadStatus != 0) throw new IllegalThreadStateException(); group.add(this); boolean started = false; try { start0(); started = true; } finally { try { if (!started) { group.threadStartFailed(this); } } catch (Throwable ignore) { } } } private native void start0();
start0是本地方法,最后还是调用了Thread的run方法
@Override public void run() { if (target != null) { target.run(); } }
(d): 客户端使用? ---> public Thread(Runnable target) 使用构造方法传入,调用start方法启动线程,可见start方法调用了run方法。
Thread thread = new Thread(new MyRunnable()); thread.start();
通过上面的分析,我们平常使用的线程也使用了策略设计模式,只是这里的策略具体实现交由程序员实现,JDK为我们提供了策略接口、策略上下文等。
5、总结
策略设计模式一般实现步骤如下:
a、编写策略接口
b、编写策略实现类
c、编写策略执行上下文,一般这个类持有一个策略接口属性,通过构造函数为其赋值,并且该类有一个主要的入口函数,该函数有很多个操作步骤,其中某一个步骤要使用算法(也就是接口方法)。
d、客户端在使用的时候,首先使用策略执行上下文这个类的构造函数传入策略实现类,接着调用策略执行上下文这个类的主要入口函数,就可以执行到算法。通过构造函数传入不同的策略实现类,就可以更换程序的算法逻辑。
策略设计模式缺点就是客户端需要知道所有的策略实现类。
原文:https://www.cnblogs.com/yefengyu/p/10527350.html