“你相熟设计模式吗？”
“我最相熟单例模式。”
你张开嘴巴，自信一吼，散发荣耀🌈
知面不知心
即便没吃过猪肉，但也见过猪跑。问起设计模式，必不可缺少的就是单例模式。
单例模式：保障一个类只有一个实例， 并提供一个拜访该实例的全局节点
翻译：创立一个惟一类对象，保障内部每次应用都是这个惟一对象。
随后你又写下实现代码，来证实本人 “很懂” 单例，毕竟它是如此简略！
-
创立单例类
public class SingleObject { private static SingleObject instance = new SingleObject(); private SingleObject() {} public static SingleObject getInstance() { return instance; } public void showMessage() { System.out.println("Hello World!"); } } - static 润饰的变量会在类加载时进行创立（记着这一点，下文会提到），并在内存中只有一份正本，应用时所有该类的实例共享同一个 static 变量。即便咱们通过 对象.动态变量名 进行拜访，虽对象内存不同，但拜访的动态变量都是同一份，所以举荐 类名.动态变量名 进行拜访更不便。
- 将 instance 设为 private 目标是保障内部无奈间接应用，须要 Get 办法拜访。
-
获取惟一对象并应用。
public class SingletonDemo { public static void main(String[] args) { SingleObject object = new SingleObject();//谬误！ 因为结构公有，所以编译报错 SingleObject object = SingleObject.getInstance();//正确 object.showMessage(); } }上述代码是咱们传统实现，也是咱们最为相熟的局部，这种实现被称之为 “饿汉式🍔”，之所以叫饿汉式是因为
SingleObject instance = new SingleObject();无论咱们是否应用 instance 对象，每当 SingleObject 类加载时就会通过 new 关键字创建对象进行内存的开拓，就犹如饿怕了的人，即便吃饱了，也要把干粮屯好，避免再受饿。
看到这里是不是感觉非常离奇，最相熟的单例居然开始变得生疏了！毕竟相熟一个人从心田开始，而相熟设计模式，也要从它的 “心田”登程。
重拾温顺的 “她”
与饿汉式相比，在类加载时不进行内存开拓，只有应用时才实例创建对象，被称之为 “懒汉式”，犹如一个人懒的感觉饿了才去吃货色。
懒汉式💤
-
线程不平安
public class Singleton { private static Singleton instance; private Singleton() { } public static Singleton getInstance() { if (instance == null) { //线程问题 instance = new Singleton(); } return instance; } }传统懒汉式存在线程问题，假如有两个线程 T1 和 T2，同时执行上述代码，当 T1 走完
if (instance == null)但没走到instance = new Singleton();，这个时候 T2 线程比它当先一步，执行了instance = new Singleton();将 instance 初始化。此时 T1 线程继续执行，将 instance 又从新初始化。因而会将 instance 初始化两次，从而违反了单例模式的意义。 -
线程平安
public class Singleton { private static Singleton instance; private Singleton (){} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }通过 synchronized 保障了线程平安，然而因为每个线程执行到 getInstance 办法时都得期待锁的开释，因而会影响性能，所以就有了双重校验锁模式。
双重校验锁🔒
-
谬误双重校验锁
public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { // Time1 synchronized (Singleton.class) { //Time2 if (instance == null) { instance = new Singleton(); //指令重排 } } } return singleton; } }第一个 if 对 instance 进行判断，如果初始化实现即 !=null 则间接返回。如果 ==null 继续执行，当多个线程执行到 Time1 时会期待锁的开释，当持有锁的线程开释后，其余线程会抢锁，而后某个线程从新拿到锁继续执行，并在 Time2 处从新判断 instance 是否为空，因为之前线程曾经把 instance 初始化，所以间接返回，防止反复赋值。
然而这是现实状态，在零碎中instance = new Singleton();被分为三步执行：
- 分配内存空间
- 初始化对象
- 将对象指向刚调配的内存空间
然而零碎为了将性能最大化，在不影响后果的状况下，会对上述步骤从新排序，有可能是这样：
- 分配内存空间
- 将对象指向刚调配的内存空间
- 初始化对象
当 T2 线程执行到 Time2 时，此时 T1 线程执行了 “将对象指向刚调配的内存空间”，还并没有初始化对象，而未被初始化的内存空间有可能是被应用过的，是有值的（具体什么值不分明），此时 T2 继续执行，拜访到初始化未实现的 instance 对象并判断 instance 不为空，之后会将未初始化对象返回，这是谬误的。❌
- 正确双重校验锁
public class Singleton {
private volatile static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}给予变量 volatile 关键字，而 volatile 作用就是禁止指令重排，因而很好的防止了上述情况。
下面太简单？ 别急，接下来介绍用更简略的办法实现双重校验锁的性能👇。
动态外部类🌳
public class Singleton {
private static class SingletonHolder {
private static final Singleton instacne = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.instacne;
}
}你是否还记得我下面让你记住的一句话：”static 润饰的变量会在类加载时进行创立”，而通过动态外部类，即便里面一层 Singleton 类被加载，但只有咱们外部 SingletonHolder 类没有被动应用，那么 instance 就不被初始化。当调用 getInstance 办法如 StaticSingleton staticSingleton = StaticSingleton.getInstance(); 才会加载 SingletonHolder 类，实例化 instance，防止内存节约。
文中代码来自菜鸟教程，作者略作改变！
我是 Haoo，一个乐观的码农，撰写乏味的文章。
如果这篇文章帮忙到你，请珍藏⭐点赞👍加关注👀，跟踪不迷路(🌻◡‿◡)
发表回复