学习多线程随笔。同时引出模板方法设计模式和回顾学习过的策略模式解决多重if--else

策略模式学习参考资料: https://www.cnblogs.com/DiDi516/p/11787257.html

什么是进程?
    可以理解成是一个操作系统上的一个应用程序,而线程是进程中的一条可执行路径;
    进程是线程的一个集合.
参考网站资料:
    https://www.cnblogs.com/aaronthon/p/9824396.html

并发 （上下执行）---- 多核CPU 并行

场景:读数据库同时对磁盘进行IO操作.
    
    ---> 如何创建线程? | 如何启动线程?  
#jps   //查看应用程序对应的端口
#jconsole + 端口 打开java监视和管理控制台.

Thread / Runnable  |  main线程 (非守护线程) 程序的入口 | 后台线程(守护线程) 比如:垃圾回收器等守护线程.

创建线程  |  线程生命周期  | 操作共享资源的多线程 ---线程安全问题. 线程本地变量  / 共享内存变量
 
匿名内部类创建线程:
        new Thread("线程01"){
            @Override
            public void run() {
          
                
                
            }
        }.start();

extends Thread  | implements Runnable  


new 新建状态  | runnable 就绪状态  | running 运行状态 |blocked 阻塞状态 | terminated 死亡状态
CPU执行权.



匿名内部类


工作逻辑的方法使用final 修饰防止子类复写.
模版方法中变化的算法。抽取出来，使用一个抽象方法。让其子类具体去实现自己的算法.

new Thread(){
    public void run(){
        System.out.println("xxxx");
    }
}.start();

线程实例调用start()方法使用了模版方法设计模式.





线程生命周期:https://www.jianshu.com/p/468c660d02da

线程生命周期:
    1.new Thread() 新建状态
    2.new Thread() .start() 线程进入 runnable 就绪状态等待系统为其分配CPU时间片。
        所以需要注意执行了start()方法就立即执行了。
        CPU在多条线程之间快速切换。
    3.根据不同的操作 线程状态在running运行  blocked 阻塞  runnable 就绪三种状态来回切换
            操作:sleep() | join() | wait() | synchronized() | notifiy() | notifyAll() | suspend()
                setPriority(int newPriority)
                setDaemon()方法.
    4.线程任务执行完之后 最终进行入 terminated 死亡状态.

- 线程对象直接调用run()方法:
    - 系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体；
    - 调用了线程的run()方法之后，该线程已经不再处于新建状态
    - 不要再次调用线程对象的start()方法。只能对处于新建状态的线程调用start()方法，
      否则将引发IllegaIThreadStateExccption异常

- 在阻塞状态的线程只能进入就绪状态，无法直接进入运行状态


为什么创建了线程实例，然后线程实例去调用start()方法? 
    ----->去查看start()方法源码 调用了本地方法native方法。C语言。调用run()方法. [使用模版方法]

> start()启动一个线程。线程执行run()方法。run()方法里面去实现自己的业务逻辑。




模版方法
   抽象类
        模版方法使用final修饰防止子类去重写.
        抽象方法 ----子类实现自己的算法逻辑。

模仿Runnable写的一个模版方法: ---------->就是为什么创建线程实例，实例去调用start()方法启动一个线程。
小技巧使用模版方法.
/**
 * 模版方法 要求是一个抽象类  .模板方法是一个final修饰的方法
 * 防止子类去重写
 */
public  abstract  class TemplateMehtod {

    public final void print(){
        System.out.println("#########################");
            wrapperMethod();
        System.out.println("###########################");
    }
    public abstract   void wrapperMethod()  ;
}


class Demo{
    public static void main(String[] args) {

        TemplateMehtod t1 = new TemplateMehtod() {
            @Override
            public void wrapperMethod() {
                System.out.println("*"+ "hello template"+"*");
            }
        };


        t1.print();

        TemplateMehtod t2 = new TemplateMehtod() {
            @Override
            public void wrapperMethod() {
                System.out.println("+"+ "hello template"+"+");
            }
        };

        t2.print();

    }
}


template模版方法属性类的行为模式.[模板方法模式把类的行为逻辑抽取为顶级逻辑。让其子类去做变化的东西]
使用场景：
    - 一个计算存款利息的例子
    - 请客吃饭


模板方法模式在Servlet中的应用：
　使用过Servlet的人都清楚，除了要在web.xml做相应的配置外，
  还需继承一个叫HttpServlet的抽象类。HttpService类提供了一个service()方法，
  这个方法调用七个do方法中的一个或几个，完成对客户端调用的响应。
  这些do方法需要由HttpServlet的具体子类提供，因此这是典型的模板方法模式

回归一下：装饰模式+ 简单工厂 + 字典map 解决多重if-else
/**
 * 回执单
 */
public class Recipte {

    private String msg;


    private String type;

    //提供set/get方法
}


/**
 * 模拟有很多回执对象
 */
public class RecipteBuilder {


    public static List<Recipte> recipteList() {
        List<Recipte> recipteList = new ArrayList<>();
        recipteList.add(new Recipte("ms01----msg:ms01", "ms01"));
        recipteList.add(new Recipte("ms03----msg:ms03", "ms03"));
        recipteList.add(new Recipte("ms02----msg:ms02", "ms02"));
        recipteList.add(new Recipte("ms04----msg:ms04", "ms04"));

        return recipteList;
    }


}

/**
 * 处理回执对象的策略对象接口
 */
public interface RecipteStrategyHandler {

      void handler(Recipte recipte);

}

/*
每种回执类型对象  对应的 策略处理
*/
public class Ms01RecipterStrategyHandler implements RecipteStrategyHandler {
    @Override
    public void handler(Recipte recipte) {
        System.out.println(" type:"+recipte.getType()+"--->Ms01RecipterStrategyHandler");
    }
}

。。。其他策略实现类差不多的这里就先不忙写了。。。。。


 
/**
 * 管理回执策略对象的上下文的一个类.
 */
public class RecipterStrategyContext {
    
    //聚合模式 ----类和类关系的一种依赖关系   recipteStrategyHandler 通过工厂创建然后赋值给上下文对象的他
    private RecipteStrategyHandler recipteStrategyHandler;

    public void setRecipteStrategyHandler(RecipteStrategyHandler recipteStrategyHandler){
        this.recipteStrategyHandler = recipteStrategyHandler;
    }
    
    //上下文对象中提供一个对策略对象处理的公共方法。把回执对象传递过来
    public void handler(Recipte recipte){
        if(recipte !=null){
            recipteStrategyHandler.handler(recipte);
        }
    }
 

}


/**
 * 策略工厂创建策略对象. map key-value的形式来创建对应类型的策略实现类对象
 */
public class RecipterFactory {

    private  Map<String, RecipteStrategyHandler> map;


    public  RecipterFactory(){
        this.map = new HashMap<>();
        this.map.put("ms01",new Ms01RecipterStrategyHandler());
        this.map.put("ms02",new Ms02RecipterStrategyHandler());
        this.map.put("ms03",new Ms03RecipterStrategyHandler());
        this.map.put("ms04",new Ms04RecipterStrategyHandler());
    }


    public  RecipteStrategyHandler createRecipteStrategy(String type){
        return map.get(type);
    }

}


/**
 * 策略工厂创建策略对象. map key-value的形式来创建对应类型的策略实现类对象
 */
public class RecipterFactory {

    private  Map<String, RecipteStrategyHandler> map;


    public  RecipterFactory(){
        this.map = new HashMap<>();
        this.map.put("ms01",new Ms01RecipterStrategyHandler());
        this.map.put("ms02",new Ms02RecipterStrategyHandler());
        this.map.put("ms03",new Ms03RecipterStrategyHandler());
        this.map.put("ms04",new Ms04RecipterStrategyHandler());
  
    }


    public  RecipteStrategyHandler createRecipteStrategy(String type){
        return map.get(type);
    }
}


public class RecipterClient {
    public static void main(String[] args) {

        List<Recipte> recipteList = RecipteBuilder.recipteList();


        //常见回执策略上下文
        RecipterStrategyContext recipterStrategyContext = new RecipterStrategyContext();
        for (Recipte recipte : recipteList) {
            //通过recipte 获取对应的 策略处理

            RecipterFactory recipterFactory = new RecipterFactory();
            RecipteStrategyHandler recipteStrategy = recipterFactory.createRecipteStrategy(recipte.getType());
            //给上下文中组合对象赋值
            recipterStrategyContext.setRecipteStrategyHandler(recipteStrategy);
            //调用上下文中的。提供的策略处理方法
            recipterStrategyContext.handler(recipte);
        }
 
    }
}