JavaEE初阶第七节.多线程(基础篇)单例模式案例一

作者简介：大家好，我是未央；

博客首页：未央.303

系列专栏：JavaEE初阶

每日一句：人的一生，可以有所作为的时机只有一次，那就是现在！！！!

文章目录

前言

一、单例模式的概念

二、单例模式的简单实

          2.1 饿汉模式

          2.2 懒汉模式

总结

---

前言

前面已经向各位铁铁们介绍了 关于多线程的一些基本的知识点，为了可以让大家更好的理解 多线程的一些相关的特性，这篇博客 就会结合着一些具体的代码案例 来向大家介绍；

今天将介绍第一个多线程案例————单例模式；

---

 一、单例模式的概念

所谓单例模式，是一种常见的设计模式；

单例模式希望：有些对象，在一个程序中应该只有唯一个一个地个实例，就可以使用单例模式；

换句话说，在单例模式下，对象的实例化被限制了，只能创建一个，多了也创建不了；

如果光是靠人来保证，是不靠谱的，所以就借助语法，强行限制不可以创建多个实例，避免程序员不小心出错；

设计模式：类似于棋谱，是 前辈们已经总结好了的一些固定套路，照着棋谱来下棋，棋就不会下的太差，这就提高了下限（比如说，象棋 ......）；

二、单例模式的简单实现

在 Java 里面的单例模式，有很多种实现方式，在这里主要介绍两个大类：饿汉模式、懒汉模式 ；

饿汉模式 和 懒汉模式 两种模式，描述了创建实例的时间；

这两种模式，并没有什么高低贵贱之分，不是 现实生活中的 "贬义词"，相反 在计算机领域，"懒"还是一个褒义词，这个字意味着计算机的性能比较高；

在计算机中，这种思想是很常见的；

比如说，想要了解某个资料（大文件 10G，存放在硬盘中），那么 此时使用某个编辑器，打开文件，就会出现两种情况：

[饿汉] 把 10G 都读到内存中，读取完毕之后 再允许用户进行查看和修改
[懒汉] 只读取一点点（当前屏幕能显示出的范围），随着用户翻页，继续再读后续内容
所以说，如果是 饿汉模式，那么显示所需要的时间就会比较多；如果是 懒汉模式，那么显示的时间就会比较低，效率就会比较高（也有可能 用户打开文件以后，只看了两眼就关了，后面的大部分都没有读，那么内存读了那么多也没有意义）

所以，通常我们都认为，懒汉模式 要比 饿汉模式 更高效

当然，还有 刷抖音、看小说、看微信、上网浏览内容 ...... 的时候，都是借鉴了 懒汉模式

2.1 饿汉模式 

饿汉模式 的意思是，程序一旦启动，就会立刻创建实例；

这就好比，一个饿了的人，看到一张饼，就会迫不及待的往嘴里塞，我们把它叫做 "饿汉"

static关键字 的来龙去脉：

static 名字叫做 "静态"，但是实际上和字面意思没有任何的关系，这是一个历史遗留的问题

实际表示的含义是 "类属性 / 类方法"，同样的，我们把 不是静态的普通的成员叫做 "实例属性 / 实例方法"

Java 里面叫做 "静态" 是因为 C 里面表示 "类属性"，就是用 static，Java 是从 C 那里抄来的；而 C 则是因为 引入面向对象之后。需要搞一个方式来定义类属性，就需要引入一个关键字，但是引入新的关键字 成本极高，所以关键字设计者的大佬们 目光就盯住了 旧的关键字

于是，static 就中招了，static 原来表示的是 变量放到静态内存区，但是随着时间的推移，系统的进化，已经没有 "静态内存区" 这个说法了，但是 static关键字 还在，于是 "旧瓶装新酒"，就用来表示 "类属性 / 类方法" 了

此时，"类属性 / 类方法" 和 静不静态 字面意思上没有啥关系，只是 随便找一个之前旧的关键字，现在没啥用了，赋予一个新的功能，仅此而已

引入新的关键字成本极高的原因：

写代码的时候，变量名不能和关键字一样，当引入新的关键字的时候，不可以确定 其他人是不是已经引入了 新的关键字 作为变量名（全世界的 C 代码那么多 ......）

更大的可能是 新的关键字一引入，就会导致已有的一些代码 编译就会失败

然后这把火就会烧到了 关键字设计者 的身上

而类属性就长在类对象上，类对象在整个程序中只有唯一个一个地个实例（JVM保证的） ，所以说 类的静态成员就只有唯一个一个地个了

---

饿汉模式代码示例：

1.  
   package thread;
2.  
    
3.  
   //单例模式，饿汉的方式
4.  
   class Singleton {
5.  
   private static Singleton instance = new Singleton();
6.  
    
7.  
   //后续如果需要这个实例，就需要统一基于 getInstance 方法来获取 实力独苗，不要去 new 了~
8.  
   public static Singleton getInstance() {
9.  
   return instance;
10.  
    }
11.  
     
12.  
    //构造方法设为 私有，此时 其他的类想来 new 就不可以了 (通过 编译器的规则来确保只有一个实例对象)~
13.  
    private Singleton() { }
14.  
    }
15.  
    public class Demo19 {
16.  
    public static void main(String[] args) {
17.  
    //饿汉模式 的调用
18.  
    Singleton instance = Singleton.getInstance();
19.  
    Singleton instance2 = Singleton.getInstance();
20.  
    System.out.println(instance == instance2);
21.  
    }
22.  
    }

运行结果：

 如果不小心 想创建另一个实例，那么就会编译报错了：

 前面已经创建过一个实例了：

---

总结：

使用 静态成员表示实例（唯一性） 让构造方法设为私有（堵住了 new 创建新实例的口子）；

按照上面的代码，当 Singleton类 被加载的时候，就会执行到 实例化操作，此时 实例化的时机非常早（非常迫切的感觉），我们把它称为 饿汉模式；

对于饿汉模式来说，在多线程的情况下，多次调用的是 getInstance() 方法， 而 这个方法只是一个 读操作，对于多线程读操作来说，是线程安全的；

2.2 懒汉模式 

懒汉模式 的意思是，程序启动，先不着急创建实例，等到真正用的时候，再创建实例；

这个也很形象，比较 "懒"，不想干活，等到需要的时候再去干活；

---

代码示例：

1.  
   //懒汉模式的实现
2.  
   class SingletLazy {
3.  
   //此处没有立即创建实例
4.  
   private static SingletLazy instance = null;
5.  
    
6.  
   //当首次调用 getInstance() 的时候，才会创建实例
7.  
   public static SingletLazy getInstance() {
8.  
   if (instance == null) {
9.  
   instance = new SingletLazy();
10.  
    }
11.  
    return instance;
12.  
    }
13.  
     
14.  
    //同理，创建构造方法 SingletLazy()，防止该类实例化其他的对象
15.  
    private SingletLazy() { }
16.  
    }

在多线程的情况下，懒汉模式，多次调用 getInstance() 方法，而且涉及到了 两次读操作（读出 instance 是否为空，读出 返回的instance值）和 一次写操作（修改 instance 变量的值），这是线程不安全的；

当然，一旦实例创建好了以后，后续 if 条件语句就进不去了，此时也就是 全是读操作了，也就线程安全了；

---

既然已经明确了，懒汉模式 是线程不安全的，那么 如何解决懒汉模式线程不安全的问题呢？

办法就是 需要加锁！！！

通过 加锁 来保证 "判断" 和 "修改" 这组操作是原子的；

代码实现：

1.  
   //懒汉模式的实现
2.  
   class SingletLazy {
3.  
   //此处没有立即创建实例
4.  
   private static SingletLazy instance = null;
5.  
    
6.  
   //当首次调用 getInstance() 的时候，才会创建实例
7.  
   public static SingletLazy getInstance() {
8.  
   synchronized (SingletLazy.class) {
9.  
   if (instance == null) {
10.  
    instance = new SingletLazy();
11.  
    }
12.  
    }
13.  
    return instance;
14.  
    }
15.  
     
16.  
    //同理，创建构造方法 SingletLazy()，防止该类实例化其他的对象
17.  
    private SingletLazy() { }
18.  
    }

---

懒汉模式，只是在初始情况下，才会有线程不安全的问题，一旦实例创建好了以后，此时就安全了；

所以说，在后续调用 getInstance 的时候就不应该尝试加锁了；

如果使用上述的代码，无论 instance 是否为空（是否初始化），都会进行加锁，使得锁竞争加剧，消耗一些没有必要消耗的资源，就会很影响效率了；

在加锁之前，还需要进行判断 instance 是否为空（是否初始化），如果为空才会进行加锁：、

1.  
   //懒汉模式的实现
2.  
   class SingletLazy {
3.  
   //此处没有立即创建实例
4.  
   private static SingletLazy instance = null;
5.  
    
6.  
   //当首次调用 getInstance() 的时候，才会创建实例
7.  
   public static SingletLazy getInstance() {
8.  
   if (instance == null) {
9.  
   synchronized (SingletLazy.class) {
10.  
    if (instance == null) {
11.  
    instance = new SingletLazy();
12.  
    }
13.  
    }
14.  
    }
15.  
    return instance;
16.  
    }
17.  
     
18.  
    //同理，创建构造方法 SingletLazy()，防止该类实例化其他的对象
19.  
    private SingletLazy() { }
20.  
    }

分析：

外层 if 判定当前是否已经初始化好，如果未初始化好，就尝试加锁；如果已经初始化好，那么就接着往下走； 

里层 if 是在多个线程尝试初始化，产生了锁竞争，这些参与竞争的线程 拿到锁之后，再进一步确认，是否真的要初始化；

---

当然，上面的代码操作还是有一些问题的 —— 有的线程在读，有的线程在写

这就联想起了 —— 内存可见性问题

其实，这里的情况 和 之前的情况还不一样，每一个线程都有自己的上下文，都有自己的寄存器内容，按理来说 是不应该会出现优化的

但是，实际上也不好说，也并不能保证 编译器优化 是啥样的过程

因此，给 instance 加上 volatile 是更加稳健的做法

如果不加 volatile 不一定会有问题，但是 稳妥起见，还是加上更好

代码实现：

1.  
   //懒汉模式的实现
2.  
   class SingletLazy {
3.  
   //此处没有立即创建实例
4.  
   volatile private static SingletLazy instance = null;
5.  
    
6.  
   //当首次调用 getInstance() 的时候，才会创建实例
7.  
   public static SingletLazy getInstance() {
8.  
   if (instance == null) {
9.  
   synchronized (SingletLazy.class) {
10.  
    if (instance == null) {
11.  
    instance = new SingletLazy();
12.  
    }
13.  
    }
14.  
    }
15.  
    return instance;
16.  
    }
17.  
     
18.  
    //同理，创建构造方法 SingletLazy()，防止该类实例化其他的对象
19.  
    private SingletLazy() { }
20.  
    }

总结：

懒汉模式 线程的三个要点：

1. 加锁
2. 双重 if
3. volatile（不加可能是错的，但加了一定是正确的）

---

总结

今天我们介绍了有关多线程的案例的单例模式的有关内容，下一节我们将继续介绍其他的案例，让我们拭目以待吧！！！！！！！！！

这篇好文章是转载于：学新通技术网