1. 单例模式
单例模式是一种设计模式，设计模式是我们必须要掌握的一个技能；
1.1 关于框架和设计模式
设计模式是软性的规定，且框架是硬性的规定，这些都是技术大佬已经设计好的；
一般来说设计模式有很多种，且不同的语言会有不同的设计模式，（同时设计模式也可以理解为对编程语言的一种补充）
1.2 细说单例模式
单例 = 单个实例（对象）；
某个类，在一个线程中，只应该创建一个实例化对象（原则上不应该有多个），这时就使用单例模式，如此可以对我们的代码进行一个更严格的校验和检查。
保证对象唯一性的方法：
方法一，可以通过“协议约束”，写一个文档，规定这个类只能有唯一的实例，程序员在接手这个代码时，就会发现这个文档已经进行约定，其中的规定约束着程序员在创建对象时，时刻注意只能创建一个对象。
方法二：从机器入手；让机器帮我们检查，我们期望让机器帮我们对代码中指定的类，创建类的实例个数进行检查、校验，当创建的实例个数超过我们期望个数，就编译报错。其中单例模式就是已经设计好的套路，可以实现这种预期效果。
关于单例模式代码实现的基本方式有两种：饿汉模式和懒汉模式；
2. 饿汉模式
饿汉模式是指创建实例的时期非常早；在类加载的时候，程序一启动，就已经创建好实例了，使用 “饿汉”这个词，就是形容创建实例非常迫切，非常早。单例模式代码如下：
class Singleton {
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
private Singleton(){ }
}
public class TestDemo4 {
public static void main(String[] args) {
Singleton singleton = new Singleton();
}
}当我们运行该代码时，系统就会报错，接下来我们详细的分析一下此处的代码；
这样，如果我们想new一个Singleton对象，也new不了，同时不管我们用getInstance获取多少次实例，获取的对象都是同一个对象，代码如下：
package thread;
// 就期望这个类只能有唯一的实例 (一个进程中)
class Singleton {
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
private Singleton() {}
}
public class ThreadDemo26 {
public static void main(String[] args) {
// Singleton s = new Singleton();
Singleton s = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s == s2);
}
}
结果如下：
3. 懒汉模式
和饿汉模式不一样的是，懒汉模式创建实例的时机比较晚，没饿汉创建实例那么迫切，只有第一次使用这个类时，才会创建实例，代码如下：
class SingletonLazy {
private static SingletonLazy instance = null;
public static SingletonLazy getInstance() {
if(instance == null) {
instance = new SingletonLazy();
}
return instance;
}
private SingletonLazy() { }
}
public class TestDemo5 {
public static void main(String[] args) {
}
}下面为代码图解分析：
和饿汉模式的区别就是没那么迫切创建实例，等需要调用这个类的时候才创建一个实例，而饿汉模式是有了这个类就创建出实例。
懒汉模式的优点：有的程序，要在一定条件下，才需要进行相关的操作，有时候不满足这个条件，也就不需要完成这个操作了，如此哦·就把这个操作省下来了。
4. 两种模式关于线程安全
4.1 饿汉模式
线程安全；
对于饿汉模式来说，上图所示通过调用getinstance方法来返回instance对象，本质上来说是读操作；
当有多个线程，同时并发执行，调用getInstance方法，取instance，这时线程是安全的，因为只涉及到读，多线程读取同一个变量，是线程安全的。而instance很早之前就已经创建好了，不会修改它，一直也只有这一个实例，也不涉及写的操作。
4.2 懒汉模式
线程不安全；
在懒汉模式中，条件判定和返回时是读操作，new一个对象是写操作；
我们只有调用getInstance方法后，就会创建出实例来，如果多个线程同时调用这个方法，此时SingletonLazy类里面的instance都为null，那么这些线程都会new对象，就会创建多个实例。这时，就不符合我们单例模式的预期了，所以，这个代码是线程不安全的。
线程不安全的直接原因，就是 “写” 操作不是原子的。
4.3 解决懒汉模式的线程安全问题
4.3.1 把写操作打包成原子
因为多线程并发执行的时候，可能读到的都是instance == null，所以会创建多个实例，那我们就给它加锁，让它在创建实例的时候，只能创建一个，加锁代码如下：
class SingletonLazy {
private static Object locker = new Object();
private static SingletonLazy instance = null;
public static SingletonLazy getInstance() {
synchronized (locker) {
if(instance == null) {
instance = new SingletonLazy();
}
}
return instance;
}
private SingletonLazy() { }
}以上操作虽然将写操作打包成了一个原子，但是新的问题也出现了；
4.3.2 去除冗余操作
上述操作加上了还是有问题：如果已经创建出实例了，我们还有加锁来判断它是不是null吗，加锁这些操作也是要消耗硬件资源的，没有必要为此浪费资源空间，如果已经不是null了，我们就想让它直接返回，不再进行加锁操作，代码修改如下：
class SingletonLazy {
private static Object locker = new Object();
private static SingletonLazy instance = null;
public static SingletonLazy getInstance() {
if (instance == null) {
synchronized (locker) {
if (instance == null) {
instance = new SingletonLazy();
}
}
}
return instance;
}
private SingletonLazy() { }
}代码图解分析两个判断语句的是目的意义：
4.3.3 指令重排序的问题
指令重排序：指令重排序也是编译器的一种优化，在保证原代码的逻辑不变，调整原代码的指令执行顺序，从而让程序的执行效率提高。
保证原代码的逻辑不变，改变原有指令的顺序，从而提高代码的执行效率，其中这个代码，就存在着指令重排序的优化，如下图代码：
该语句原本指令执行顺序：
1、去内存申请一段空间
2、在这个内存中调用构造方法，创建实例
3、从内存中取出地址，赋值给这个实例instance。
指令重排序后的顺序：1, 3 , 2；按照指令重排序后的代码执行逻辑就变成了下面所示：
假设有两个线程，现在执行顺序如下图所示：
因为指令重排序后，先去内存申请一段空间，然后是赋值给instance，那这时，instance就不是null了，第二个线程不会进入到if语句了，直接返回instance，可是instance还没有创建出实例，这样返回肯定是有问题的，如此也就线程不安全了。
解决方案：
给instance这个变量，加volatile修饰，强制取消编译器的优化，不能指令重排序，同时也排除了内存可见性的问题。
加volatile后的代码如下：
class SingletonLazy { private static Object locker = new Object(); private static volatile SingletonLazy instance = null; public static SingletonLazy getInstance() { if (instance == null) { synchronized (locker) { if (instance == null) { instance = new SingletonLazy(); } } } return instance; } private SingletonLazy() { } }至此，我们才算解决掉懒汉模式关于线程安全的所有问题；
4.4 懒汉模式线程安全的代码
package thread;
// 懒汉的方式实现单例模式.
class SingletonLazy {
// 这个引用指向唯一实例. 这个引用先初始化为 null, 而不是立即创建实例
private volatile static SingletonLazy instance = null;
private static Object locker = new Object();
public static SingletonLazy getInstance() {
// 如果 Instance 为 null, 就说明是首次调用, 首次调用就需要考虑线程安全问题, 就要加锁.
// 如果非 null, 就说明是后续的调用, 就不必加锁了.
if (instance == null) {
synchronized (locker) {
if (instance == null) {
instance = new SingletonLazy();
}
}
}
return instance;
}
private SingletonLazy() { }
}
public class ThreadDemo27 {
public static void main(String[] args) {
SingletonLazy s1 = SingletonLazy.getInstance();
SingletonLazy s2 = SingletonLazy.getInstance();
System.out.println(s1 == s2);
}
}
结果如下：
文章来源：https://www.toymoban.com/news/detail-774048.html
ps:本次的内容就到这里了，如果感兴趣的话，就请一键三连哦！！！文章来源地址https://www.toymoban.com/news/detail-774048.html
到了这里，关于【Java EE初阶六】多线程案例（单例模式）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
