多线程之策略模式

Posted 2020-09-29 赵小忠

       今天天气非常好，下着淅淅沥沥的小雨，刮着风，感觉甚好；我在北京向各位问好。这几天公司基本没什么事儿，从昨天开始就复习了一下多线程编程，今天给各位分享一种Java23种设计模式中最常见的设计模式--策略模式。为什么将策略模式和多线程绑在一起呢，不知道各位有没有注意过我们在进行多线程编程的时候，创建线程的方式有2种，一种是继承Thread类，另外一种就是实现Runnable接口；当然，我们会毫不保留的选择第二种，因为扩展性强，习惯接口开发等等原因，但是第二种方式还潜藏了23种Java设计模式中的其中一个模式，那就是低调而又强势的"策略模式"。

       说说策略模式吧，这种模式的设计思想就是：为了考虑业务逻辑的千变万化和复杂程度是不一定的，因此我们需要对这套程序进行高度的抽象，这样才能将业务逻辑和抽象进行相分离，才能够让这套程序的可扩展性变的极强，这也是在开发中会使用策略模式的强大之处。好了读到这儿，我相信从来没有接触过这种设计模式的读者来说，还是一头雾水，接下来我就开始通过多线程来请出我们的"策略模式"。

       先看代码再解释：

 1 public static void main(String[] args) {
 2         //创建线程一：
 3         new Thread(new Runnable() {
 4             @Override
 5             public void run() {
 6                 int i=100;
 7                 while(i>0){
 8                     System.out.println("创建的线程一："+i--);
 9                 }
10             }
11         }).start();
12         //创建线程二：
13         new Thread(new Runnable() {
14             @Override
15             public void run() {
16                 int i=100;
17                 while(i>50){
18                     System.out.println("创建的线程二："+i--);
19                 }
20             }
21         }).start();
22         //主线程：
23         int i=0;
24         while(i<100){
25             System.out.println("主线程："+i++);
26         }
27 
28     }

       上面这段代码是一个最简单的多线程案例，这段程序总共由3个线程来同时执行(当然除此之外还有Java虚拟机的垃圾回收等等其他一些线程)，并交错打印变量的值。在这儿我们先暂时停一下，我想反问各位一个问题，为什么我们重写的是Runnable接口的run()方法，但是开启线程的却是start()方法?没错，正是"策略模式"在操控，什么？还有这种操作。哈哈哈，我当时学习这种设计模式的时候也是各种奇怪，各种撞墙，不过还好我通过了一个实例至少简单明白了它是如何操控的。

下面我就通过一个实例让各位读者切身体会一下策略模式的好处和强大。需求：设计一个随心所欲的算法器？

       第一步：只需设计一个算法接口即可，主要是因为规范或者让程序知道如何进行调用。

1 /**
2  * 算法接口
3  * @author zxz
4  *
5  */
6 interface CalculatorInterface{
7     int calc(int x,int y);
8 }

       第二步：就是整个程序的结构，也就是算法器的高度抽象部分，里面约束了整个程序的框架和大概流程，但是最重要的是并未涉及到业务层面的东西，因为我这个需求是设计一个算法器，肯定是有数据流入流出的，那么它就是将数据的流入流出做了规范，只是提供了一个默认的逻辑实现。

 1 /**
 2  * 算法器
 3  */
 4 class Calculator{
 5     private int x=0;
 6     private int y=0;
 7     private CalculatorInterface calculatorInterface = null;
 8     
 9     public Calculator(int x, int y) {
10         this.x = x;
11         this.y = y;
12     }
13     
14     public Calculator(int x, int y,CalculatorInterface calculatorInterface) {
15         this(x,y);
16         this.calculatorInterface = calculatorInterface;
17     }
18     
19     public int calc(int x,int y){
20         return x+y;
21     }
22     //只需关注接口，并且将接口用到的参数传递进去即可，不必担心具体的业务是如何封装的【这段代码请各位好好斟酌】
23     public int result(){
24         if(null!=calculatorInterface){
25             return calculatorInterface.calc(x, y);
26         }
27         return calc(x, y);
28     }
29 }

       第三步：额外定义加法和减法算法类，为了下面的测试使用。

 1 /**
 2  * 加法算法
 3  */
 4 class AddStrategy implements CalculatorInterface{
 5     @Override
 6     public int calc(int x, int y) {
 7         return x+y;
 8     }
 9 }
10 /**
11  * 减法算法
12  */
13 class SubStrategy implements CalculatorInterface{
14     @Override
15     public int calc(int x, int y) {
16         return x-y;
17     }
18 }

       第四步：我们开始测试，看看现象应该就能明白策略模式是如何低调的。

 1 /**
 2  * 主程序
 3  */
 4 public class Strategy {
 5     
 6     public static void main(String[] args) {
 7         //没有任何策略时的结果
 8         Calculator c = new Calculator(33, 3);
 9         System.out.println(c.result());
10         
11         //传入减法策略的结果
12         Calculator c1 = new Calculator(33, 3,new SubStrategy());
13         System.out.println(c1.result());
14         
15         //【是时候展示真正的技术了】策略模式的强大，在这里算法可以随意设置，只要你使用接口方式创建对象
16         int result = new Calculator(33, 3,new CalculatorInterface() {
17             @Override
18             public int calc(int x, int y) {
19                 return (x+y)/2;
20             }
21         }).result();
22         System.out.println(result);
23     }
24 
25 }

       最后，策略设计模式的实现过程算是完成了，主要就是这套代码，需要各位自己斟酌，如有不对的地方留言指正，共勉。