初学Java常用设计模式之—

0. 常⻅的三⼤设计模式分类

创建型模式：提供了⼀种在创建对象的同时隐藏创建逻辑的⽅式，使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活，比如：
- 常用4个：⼯⼚模式、抽象⼯⼚模式、单例模式、建造者模式
- 不常用：原型模式
结构型模式：关注类和对象的组合。继承的概念被⽤来组合接⼝和定义组合对象获得新功能的⽅式
- 常⽤4个：适配器模式、桥接模式、装饰器模式、代理模式
- 不常⽤：组合模式、外观模式、享元模式
⾏为型模式：特别关注对象之间的通信
- 常⽤6个：责任链模式、迭代器模式、观察者模式、状态模式、策略模式、模板模式
- 不常⽤：备忘录模式、命令模式
- ⼏乎不⽤：访问者模式、中介者模式、解释器模式

1. 单例模式(常用)

单例模式使⽤场景：
- 业务系统全局只需要⼀个对象实例，⽐如发号器、 redis 连接对象等
- Spring IOC容器中的 bean 默认就是单例
- spring boot 中的controller、service、dao层中通过 @autowire的依赖注⼊对象默认都是单例的
单例模式分类：
- 懒汉：就是所谓的懒加载，延迟创建对象，需要用的时候再创建对象
- 饿汉：与懒汉相反，提前创建对象
单例模式实现步骤：
- 私有化构造函数
- 提供获取单例的⽅法

1.1 单例模式——懒汉式

单例模式——懒汉式有以下⼏种实现⽅式：

/*** @Auther: csp1999* @Date: 2020/11/06/20:36* @Description: 单例设计模式-懒汉式*/
public class SingletonLazy {// 当需要用到该实例的时候再创建实例对象private static SingletonLazy instance;/*** 构造函数私有化* 不能通过 new SingletonLazy() 的方式创建实例* * 当需要用到该实例的时候在加载* 只能通过 SingletonLazy.getInstance() 这种方式获取实例*/private SingletonLazy() {}/*** 单例对象的方法*/public void process() {System.out.println("方法实例化成功！");}/*** 方式一：* <p>* 对外暴露一个方法获取该类的对象* <p>* 缺点：线程不安全，多线程下存在安全问题** @return*/public static SingletonLazy getInstance() {if (instance == null) {// 实例为null时候才创建/*** 线程安全问题：* 当某一时刻，两个或多个线程同时判断到instance == null成立的时候* 这些线程同时进入该if判断内部执行实例化* 则会新建出不止一个SingletonLazy实例*/instance = new SingletonLazy();// 当需要的时候再进行实例化对象}return instance;}/*** 方式二：* 通过加synchronized锁 保证线程安全** 采用synchronized 对方法加锁有很大的性能开销* 因为当getInstance2()内部逻辑比较复杂的时候，在高并发条件下* 没获取到加锁方法执行权的线程，都得等到这个方法内的复杂逻辑执行完后才能执行，等待浪费时间，效率比较低** @return*/public static synchronized SingletonLazy getInstance2() {if (instance == null) {// 实例为null时候才创建// 方法上加synchronized锁后可以保证线程安全instance = new SingletonLazy();// 当需要的时候再进行实例化对象}return instance;}/*** 方式三：* 在getInstance3()方法内，针对局部需要加锁的代码块加锁，而不是给整个方法加锁** 也存在缺陷：* @return*/public static SingletonLazy getInstance3() {if (instance == null) {// 实例为null时候才创建// 局部加锁后可以保证线程安全,效率较高// 缺陷：假设线程A和线程Bsynchronized (SingletonLazy.class){// 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化// 当A线程执行完毕后，B再获得执行权，这时候还是可以实例化该对象instance = new SingletonLazy();// 当需要的时候再进行实例化对象}}return instance;}
}

单例模式：懒汉实现+双重检查锁定+内存模型

对于上面方式三存在的缺陷，我们可以使用双重检查锁定的方式对其进行改进：

/*** 方式三改进版本：* 在getInstance3()方法内，针对局部需要加锁的代码块加锁，而不是给整个方法加锁** DCL 双重检查锁定 (Double-Checked-Locking) 在多线程情况下保持高性能** 这是否安全？ instance = new SingletonLazy(); 并不是原子性操作* jvm中 instance实例化内存模型流程如下：* 1.分配空间给对象* 2.在空间内创建对象* 3.将对象赋值给instance引用** 假如出现如下顺序错乱的情况：* 线程的执行顺序为：1 -> 3 -> 2, 那么这时候会把值写回主内存* 则，其他线程就会读取到instance的最新值,但是这个是不完全的对象* (指令重排现象)** @return*/
public static SingletonLazy getInstance3plus() {if (instance == null) {// 实例为null时候才创建// 局部加锁后可以保证线程安全,效率较高// 假设线程A和线程B synchronized (SingletonLazy.class){// 第一重检查// 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化// 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立// 如果不成立，B线程无法 实例化SingletonLazyif (instance == null){// 第二重检查instance = new SingletonLazy();// 当需要的时候再进行实例化对象}}}return instance;
}

再次升级方式三，来解决内存模型中的指令重排问题：

// 添加volatile 关键字，禁止实例化对象时，内存模型中出现指令重排现象
private static volatile SingletonLazy instance;/*** 方式三再次升级版本：* 在getInstance3()方法内，针对局部需要加锁的代码块加锁，而不是给整个方法加锁** DCL 双重检查锁定 (Double-Checked-Locking) 在多线程情况下保持高性能** 解决指令重排问题——禁止指令重排* @return*/
public static SingletonLazy getInstance3plusplus() {if (instance == null) {// 实例为null时候才创建// 局部加锁后可以保证线程安全,效率较高// 假设线程A和线程Bsynchronized (SingletonLazy.class){// 第一重检查// 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化// 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立// 如果不成立，B线程无法 实例化SingletonLazyif (instance == null){// 第二重检查instance = new SingletonLazy();// 当需要的时候再进行实例化对象}}}return instance;
}

单例模式——懒汉式调用：

@Test
public void testSingletonLazy(){SingletonLazy.getInstance().process();
}

扩展——什么是指令重排以及如何禁止指令重排？

什么是指令重排？(之后学习JVM相关知识后，还会再分享博客给大家)

首先编译器执行指令的时候会存在指令重排的情况，以便于提高指令的执行速度。就像是考试一样，肯定是先把会的题做完再做难的题目。

什么时候会发生重排呢？

如果两个指令之间不会存在依赖性，例如： a = 1; y = a+1。这两个语句就不会发生指令重排，因为y的值依赖a的值；所以a的赋值语句会先于y执行，但是如果是： a =1 ; y = 2。这两个语句就会发生，因为二者不存在依赖。

在单线程的条件下，指令重排不会影响到最终的结果，也就是数据的一致性可以得到保证；
但是在多线程的条件下，各种线程交替执行，两个线程间使用的变量能否保证一致性就不能得到保证。

我们来分析两个案例，来了解指令重排：

案例一：

// 伪代码：初始化变量
int x,y = 0;
int a,b = 0;
--------------
// 线程一执行：
x=a;
b=1;
--------------
// 线程二执行：
y=b；
a=3;

线程一	线程二
x=a	y=b
b=1	a=3

在上述条件下，如果正常的话，执行结束之后的结果为，x 和y 的值应该还是0；
但是由于存JVM内存模型中存在指令重排，那么线程一可以先执行b=1;然后再执行x=a;
同理线程二可以先执行a=3; 再执行 y=b;
我们都知道多线程情况下，线程之间抢占资源的顺序没有先后之分都是随机的，因此，不排除会出现下面的情况：
- 当线程一刚执行完b=1;，在执行x=a;指令之前，线程二抢先执行了 y=b;，那么这时候y就被赋值了1
- 当线程二刚执行完a=3; ，在执行 y=b;指令之前，线程一抢先执行了x=a;，那么这时候x就被赋值了3
- 最终结果为x =3， y=1

案例二：

public class SortSeqDemo {int a = 0;boolean flag = false;public void method01() {a = 1;flag = true;}public void method02() {if (flag) {a = a+5;System.out.println(a);}}
}

在这个案例中，如果执行method01() 方法的时候，a=1; flag = true； 这两个语句的执行顺序不能被保证，所以另一个线程执行method02()方法最终打印出来的a的值可能存在两种情况，a = 6 or a = 5。

而volatile就可以解决指令重排，它使用的是内存屏障进行解决的，所谓的内存屏障是一个cpu命令，它有两个作用保证特定的执行顺序，保证可见性，通过在volatile 指令前后增加内存屏障从而解决指令重排问题。

当然这只是JVM内存模型和指令重排的简单介绍，之后在更新JVM学习笔记的时候会和大家一起深入学习这一块知识点！

1.2 单例模式——饿汉式

/*** @Auther: csp1999* @Date: 2020/11/06/21:39* @Description: 单例设计模式-饿汉式*/
public class SingletonHungry {// 当类加载的时候就直接实例化对象private static SingletonHungry instance = new SingletonHungry();private SingletonHungry(){}/*** 单例对象的方法*/public void process() {System.out.println("方法实例化成功！");}public static SingletonHungry getInstance(){return instance;// 当类加载的时候就直接实例化对象}
}

单例模式——饿汉式调用：

@Test
public void testSingletonHungry(){SingletonHungry.getInstance().process();
}

饿汉式单例模式，当类加载的时候就直接实例化对象，因此不需要考虑线程安全问题。

优点：实现简单，不需要考虑线程安全问题
缺点：不管有没有使用该对象实例，instance对象一直占用着这段内存

懒汉与饿汉式如何选择？

如果对象内存占用不大，且创建不复杂，直接使用饿汉的方式即可
其他情况均采用懒汉方式(优选)

之后我会陆续更新其他设计模式博文，如果文章对您有帮助，希望点个赞加个收藏O(∩_∩)O~