初学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和线程B synchronized (SingletonLazy.class){ // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化 // 当A线程执行完毕后，B再获得执行权，这时候还是可以实例化该对象 instance = new SingletonLazy();// 当需要的时候再进行实例化对象 } } return instance; }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
 

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

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

/**
 * 方式三改进版本：
 * 在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;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
 

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

// 添加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;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
 

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

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

  

 

  
1
  
2
  
3
  
4
 

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

什么是指令重排？(之后学习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;

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

• 在上述条件下，如果正常的话，执行结束之后的结果为，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); } }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
 

在这个案例中， 如果执行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;// 当类加载的时候就直接实例化对象 }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
 

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

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

  

 

  
1
  
2
  
3
  
4
 

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

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

懒汉与饿汉式如何选择？

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

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

文章来源: csp1999.blog.csdn.net，作者：兴趣使然の草帽路飞，版权归原作者所有，如需转载，请联系作者。

原文链接：csp1999.blog.csdn.net/article/details/109540359