单例模式的概念
单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
单例模式的结构图如下：
单例模式和静态类的区别
单例模式和静态类都可以直接使用而无需创建对象，但是静态类是一个只包含静态方法的工具类，例如java.lang.Math。单例类是在整个生命周期内只有一个实例的类，例如java.lang.Runtime。
区别：
1.静态类不保存状态（对象属性），仅提供一些静态方法或静态属性；而单例类是有状态的
2.静态类不能用于继承多态，因为静态方法是不可以被覆盖的；单例类可以有子类来继承
3.如果是一个非常重的对象，单例类可以懒加载，静态类在类被加载的时候就会被初始化
4.静态方法中产生的对象，会随着静态方法执行完毕而释放掉，而且执行类中的静态方法时，不会实例化静态方法所在的类。如果是用singleton, 产生的那一个唯一的实例，会一直在内存中，不会被GC清除的(原因是静态的属性变量不会被GC清除)，除非整个JVM退出了。
单例模式的应用场景
1.如《大话设计模式》单例模式章节举的例子：不希望每点击一次“工具箱”的菜单项就产生一个新的“工具箱”窗体，而是希望只返回一个“工具箱”窗体。
2.网站中统计访问量的计数器
单例模式的实现方式
普通版
根据单例模式的定义实现单例模式
1.保证一个类只有一个实例。将构造方法声明为private，防止通过构造方法来实例化多个类，并定义一个私有的类的实例
2.提供一个全局访问点。定义一个静态的获取实例的方法，返回私有的类的实例
代码如下：
package com.victor.technology.singleton;
public class Singleton
{
/**
* 单例对象
*/
private static Singleton instance = null;
/**
* 单例构造函数
*/
private Singleton()
{
}
/**
* 返回单例
* @return Singleton
*/
public static Singleton getInstance()
{
if(null == instance)
{
instance = new Singleton();
}
return instance;
}
}
其中类实例的初始化是在调用getInstance()方法的时候执行的，这个写法属于单例模式的懒汉模式。
如果单例模式一开始就被new Singleton()主动构建，getInstance()方法不需要判空直接返回，这种写法属于单例模式的饿汉模式。
双重检查模式
但是上面的实现方式在多线程环境下并不能保证返回的类是单例的。例如线程A和线程B同时调用Singleton的getInstance()方法，两个线程都判断instance为null，于是各实例化了一个Singleton对象，这样就违背了“单例模式”。
对，为解决这个问题，只需要加锁即可：
package com.victor.technology.singleton;
public class Singleton
{
/**
* 单例对象
*/
private static Singleton instance = null;
/**
* 单例构造函数
*/
private Singleton()
{
}
/**
* 返回单例
* @return Singleton
*/
public static Singleton getInstance()
{
if(null == instance)
{
synchronized(Singleton.class)
{
if(null == instance)
{
instance = new Singleton();
}
}
}
return instance;
}
}
像这样两次判空的机制叫做双重检测机制，为什么这么做呢？
1.为了防止new Singleton()被执行多次，需要在操作前加上Synchronized同步锁，锁住整个类
2.进入Synchronized 临界区以后，还要再做一次判空。因为当两个线程同时访问的时候，线程A构建完对象，线程B也已经通过了最初的判空验证，不做第二次判空的话，线程B还是会再次构建instance对象。
使用volatile修饰符的双重检测模式
上述双重检测机制还有问题吗？在回答这个问题之前我们先了解一下JVM中的指令重排
什么是指令重排？
在计算机执行指令的顺序在经过程序编译器编译之后形成的指令序列，一般而言，这个指令序列是会输出确定的结果；以确保每一次的执行都有确定的结果。但是，一般情况下，CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化，在某些情况下，这种优化会带来一些执行的逻辑问题，主要的原因是代码逻辑之间是存在一定的先后顺序，在并发执行情况下，会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。
数据依赖性
主要指不同的程序指令之间的顺序是不允许进行交互的，即可称这些程序指令之间存在数据依赖性。
如下：
| 名称 | 代码示例 | 说明 |
|---|---|---|
| 写后读 | a = 1;b = a; | 写一个变量之后，再读这个位置。 |
| 写后写 | a = 1;a = 2; | 写一个变量之后，再写这个变量。 |
| 读后写 | a = b;b = 1; | 读一个变量之后，再写这个变量。 |
经过分析，发现这里每组指令中都有写操作，这个写操作的位置是不允许变化的，否则将带来不一样的执行结果。 编译器将不会对存在数据依赖性的程序指令进行重排
instance = new Singleton()会被编译器编译成如下指令：
1.分配Singleton对象的内存空间 memory=allocate()
2.初始化Singleton对象 ctorInstance(memory)
3.设置instance指向初始化之后的Singleton对象对应的内存地址 instance=memory
由于第2条指令和第3条指令没有依赖关系，有可能经过JVM和CPU的优化，指令重排成如下顺序：
1.分配Singleton对象的内存空间 memory=allocate()
2.设置instance指向初始化之后的Singleton对象对应的内存地址 instance=memory
3.初始化Singleton对象 ctorInstance(memory)
这种情况，在多线程环境下，若线程A执行完第2条指令instance已不为null，但是instance未初始化完成。此时如果线程B抢到CPU资源，执行if(null == instance)将会返回false，从而返回一个没有初始化完成的instance对象，于是线程B在使用instance的时候会发生错误。
如何避免这种错误呢？只需要在instance对象前面添加修饰符volatile：
package com.victor.technology.singleton;
public class Singleton
{
/**
* 单例对象
*/
private volatile static Singleton instance = null;
/**
* 单例构造函数
*/
private Singleton()
{
}
/**
* 返回单例
* @return Singleton
*/
public static Singleton getInstance()
{
if(null == instance)
{
synchronized(Singleton.class)
{
if(null == instance)
{
instance = new Singleton();
}
}
}
return instance;
}
}
volatile可以阻止变量访问前后的指令重排，保证指令执行的顺序。
静态内部类版
此外，还可以使用静态内部类实现单例模式：
package com.victor.technology.singleton;
public class Singleton
{
private static class LazyHolder
{
private static Singleton INSTANCE = new Singleton();
}
private Singleton()
{
}
public static Singleton getInstance()
{
return LazyHolder.INSTANCE;
}
}
1.将静态内部类声明为private，防止外部直接调用
2.只有调用getInstance()方法的时候才会加载静态内部类对Singleton对象进行初始化，属于懒汉模式，防止资源的浪费
枚举实现
但是上面几种实现方式还有一个漏洞：可以通过反射的方式打破单例模式，测试代码如下：
package com.victor.technology.singleton;
import java.lang.reflect.Constructor;
public class Main
{
public static void main(String[] args) throws Exception
{
Singleton instance1 = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance1 == instance2);
Constructor constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton instance3 = (Singleton) constructor.newInstance();
Singleton instance4 = (Singleton) constructor.newInstance();
System.out.println(instance3 == instance4);
}
}
运行结果：
true
false
可见，通过反射机制获取单例类的构造函数然后实例化得到的对象并不是单例的，那么怎么才能防止这种情况呢？答案就是使用枚举：
package com.victor.technology.singleton;
public enum Singleton
{
INSTANCE;
}
仍然执行刚才的测试代码，报错如下：
Exception in thread "main" java.lang.NoSuchMethodException:
com.victor.technology.singleton.Singleton.<init>()
at java.lang.Class.getConstructor0(Unknown Source)
at java.lang.Class.getDeclaredConstructor(Unknown Source)
at com.victor.technology.singleton.Main.main(Main.java:10)
正如《Effective Java》中说的那样单元素的枚举类型已经成为实现Singleton的最佳方法。
