学习多线程随笔。同时引出模板方法设计模式和回顾学习过的策略模式解决多重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);
}
}
}