定义
单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。
特点
- 单例类只有一个实例对象；
- 该单例对象必须由单例类自行创建；
- 单例类对外提供一个访问该单例的全局访问点。
使用场景
单例模式可以保证在一个 JVM 中只存在单一实例。单例模式的应用场景主要有以下几个方面。
- 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
- 某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
- 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
- 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
- 频繁访问数据库或文件的对象。
- 对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
- 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
模式结构
单例模式的主要角色如下。
- 单例类：包含一个实例且能自行创建这个实例的类。
- 访问类：使用单例的类。
具体实现
(1) 饿汉式--（线程安全，实用）
/**
* 单例模式--单例模式的饿汉式（线程安全，可用）
* <pre>
* (1)私有化该类的构造函数
* (2)通过new在本类中创建一个本类对象
* (3)定义一个公有的方法，将在该类中所创建的对象返回
* 优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。
* 缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到这个实例，但是它
* 也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。
* <pre>
*/
public class SingletonEHan {
private static final SingletonEHan instance = new SingletonEHan();
private SingletonEHan() {
}
private static SingletonEHan getInstance() {
return instance;
}
}(2) 懒汉式--（线程安全，可用，效率稍低）
/**
* 单例模式--懒汉式线程安全的:（线程安全，效率低，不推荐使用）
* <pre>
* 缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。
* 而其实这个方法只执行一次实例化代码就够了，
* 后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。
* </pre>
*/
public class SingletonLanHan {
private static SingletonLanHan instance = null;
private SingletonLanHan() {
}
public static synchronized SingletonLanHan getInstance() {
if (instance == null) {
instance = new SingletonLanHan();
}
return instance;
}
}(3) 懒汉式--双重校验锁（线程安全, 推荐）
/**
* 单例模式--单例模式懒汉式双重校验锁（线程安全, 推荐）
* <pre>
* 懒汉式变种,属于懒汉式的最好写法,保证了:延迟加载和线程安全
* </pre>
*/
public class SingletonDoubleCheck {
private static volatile SingletonDoubleCheck instance = null; //关键点0：声明单例对象是静态的
private SingletonDoubleCheck() { //关键点1：构造函数是私有的
}
public static SingletonDoubleCheck getInstance() { //通过静态方法来构造对象
if (instance == null) { //关键点2：判断单例对象是否已经被构造
synchronized (SingletonDoubleCheck.class) { //关键点3：加线程锁
if (instance == null) { //关键点4：二次判断单例是否已经被构造
instance = new SingletonDoubleCheck();
}
}
}
return instance;
}
}疑问：为什么instance要加volatile关键字来修饰?
解答：
instance = new SingletonDoubleCheck();分三步执行
①给 instance 分配内存
②调用 Singleton 的构造函数来初始化成员变量
③将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）。
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 ①-②-③ 也可能是 ①-③-②。如果是后者，则在 ③ 执行完毕、② 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
由于 JVM 具有指令重排的特性，有可能执行顺序变为了 ①>③>②，具体如下：
public class SingletonDoubleCheck {
private static SingletonDoubleCheck instance = null;
private SingletonDoubleCheck() {
}
public static SingletonDoubleCheck getInstance() {
if (instance == null) { // B线程检测到instance不为空
synchronized (SingletonDoubleCheck.class) {
if (instance == null) {
instance = new SingletonDoubleCheck(); // A线程被指令重排了，刚好先赋值了；但还没执行完构造函数。
}
}
}
return instance; // 后面B线程执行时将引发：对象尚未初始化错误。
}
}使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 ①-②-③ 之后或者 ①-③-② 之后，不存在执行到 ①-③ 然后取到值的情况。
(4) 静态内部类--（线程安全，推荐）
/**
* 单例模式--内部类（线程安全，推荐）
* <pre>
* 这种方式跟饿汉式方式采用的机制类似，但又有不同。
* 两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
* 不同的地方:
* 在饿汉式方式是只要Singleton类被装载就会实例化,
* 内部类是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类
* 优点：避免了线程不安全，延迟加载，效率高。
* <pre>
*/
public class SingletonLazy {
private SingletonLazy() {
}
private static class SingletonHolder {
private static final SingletonLazy INSTANCE = new SingletonLazy();
}
public static SingletonLazy getInstance() {
return SingletonHolder.INSTANCE;
}
}(5) 枚举--（线程安全，推荐）
/**
* 单例模式--枚举（线程安全，可用）
* <pre>
* 这里SingletonEnum.instance
* 这里的instance即为SingletonEnum类型的引用所以得到它就可以调用枚举中的方法了。
* 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
* </pre>
*/
public enum SingletonEnum {
INSTANCE;
public static void main(String[] args) {
SingletonEnum obj = SingletonEnum.INSTANCE;
System.out.println(obj);
}
}
