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和线程B
synchronized (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线程无法 实例化SingletonLazy
if (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和线程B
synchronized (SingletonLazy.class){// 第一重检查
// 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
// 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立
// 如果不成立，B线程无法 实例化SingletonLazy
if (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~
