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);

}

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);
            }
        }
    }

@FunctionalInterface
public interface Runnable 
{
    public abstract void run();
}

package com.yefengyu.pattern.strategy;

public class MyRunnable implements Runnable
{
    @Override
    public void run()
    {
        System.out.println("hello Runnable ");
    }
}

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(); 

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Thread thread = new Thread(new MyRunnable());

thread.start();

java策略設計模式