这是 一道面试常考题：（经常会在面试中让手写一下）
什么是单例模式
【问什么是单例模式时，不要答非所问，给出单例模式有两种类型之类的回答，要围绕单例模式的定义去展开。】
单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。
单例模式（Singleton Pattern）是一种常用的设计模式，保证一个类在内存中只有一个实例，并提供一个全局访问点。单例模式通常用于管理共享资源、控制全局状态或提供全局服务。
单例模式有两种类型：
- 懒汉式：在真正需要使用对象时才去创建该单例类对象
- 饿汉式：在类加载时已经创建好该单例对象，等待被程序使用
单例模式实现方法：
一、饿汉式单例：在类初始化时就已经自行实例化了
java
public class Singleton {
//私有静态成员变量
private static Singleton instance = new Singleton();
//私有构造方法
private Singleton(){}
//公有静态访问方法
public static Singleton getInstance()
{
return instance;
}
}注意上面的代码在第2行已经实例化好了一个Singleton对象在内存中，不会有多个Singleton对象实例存在；类在加载时会在堆内存中创建一个Singleton对象 ，当类被卸载时，Singleton对象也随之消亡了。
当然可以改为静态方块来执行实例化语句：
private static Singleton instance = null；
static{
instance = new Singleton();
}
二、懒汉式单例：在第一次调用实例的时候才实例化
如果两个线程同时判断singleton为空，那么它们都会去实例化一个Singleton对象，这就变成双例了，就不是单例了，所以可以在方法上加锁或类 对象上 加锁，
java
public class Singleton {
//私有静态成员变量
private static Singleton instance;
//私有构造方法
private Singleton(){}
//公有静态访问方法，在方法上加了一个synchronized关键字确保线程安全
public static synchronized Singleton getInstance()
{
if(instance == null)
instance = new Singleton();
return instance;
}
}
// 或者（在类对象上加锁）
public static Singleton getInstance() {
synchronized(Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
return singleton;
}这样就规避了两个线程同时创建Singleton对象的风险，但是引来另外一个问题：每次去获取对象都需要先获取锁，并发性能非常地差，极端情况下，可能会出现卡顿现象。
接下来要做的就是**优化性能，目标是：**如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例
所以直接在方法上加锁的方式就被废掉了，因为这种方式无论如何都需要先获取锁
接下来有下面的DCL
三、双重检测锁模式的懒汉式单例：（线程安全效率高）
又叫DCL懒汉式 （Double Check Lock）
java
public class Singleton {
//私有静态成员变量，加上了volatile关键字确保可见性
private volatile static Singleton instance = null;
//私有构造方法
private Singleton(){}
//公有静态访问方法
public static Singleton getInstance(){
if(instance == null){ //线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
synchronized (Singleton.class){ //线程A或线程B获得该锁进行初始化；获取锁这里利用到volatile关键字的可见性，再次判断空
if(instance == null) //其中一个线程进入该分支，另外一个线程则不会进入该分支，此时instance真的为空，才去创建实例
instance = new Singleton();
}
}
return instance;
}
}
注意： synchronized 解决并发问题，但是因为lazyMan = new LazyMan();不是原子性操作(可以分割，见代码注释)，可能发生指令重排序的问题，通过volatil来解决
- Java 语言提供了 volatile和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含"禁止指令重排序"的语义，synchronized 是由"一个变量在同一个时刻只允许一条线程对其进行 lock 操作"这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。
- 原子性就是指该操作是不可再分的。不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作。简而言之，在整个操作过程中不会被线程调度器中断的操作，都可认为是原子性。比如 a = 1；
指令重排序是指：JVM在保证最终结果正确的情况下，可以不按照程序编码的顺序执行语句，尽可能提高程序的性能
- 使用volatile关键字可以防止指令重排序， 其原理较为复杂，这篇博客不打算展开，可以这样理解：使用volatile关键字修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换，这样在多线程环境下就不会发生NPE异常了。
- volatile还有第二个作用：使用volatile关键字修饰的变量，可以保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。
四、破坏懒汉式单例与饿汉式单例
无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象）。
1.演示利用反射破坏单例模式
java
public static void main(String[] args) {
// 获取类的显式构造器
Constructor<Singleton> construct = Singleton.class.getDeclaredConstructor();
// 可访问私有构造器
construct.setAccessible(true);
// 利用反射构造新对象
Singleton obj1 = construct.newInstance();
// 通过正常方式获取单例对象
Singleton obj2 = Singleton.getInstance();
System.out.println(obj1 == obj2); // false
}上述的代码一针见血了：利用反射，强制访问类的私有构造器，去创建另一个对象
2.利用序列化与反序列化破坏单例模式
java
public static void main(String[] args) {
// 创建输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.file"));
// 将单例对象写到文件中
oos.writeObject(Singleton.getInstance());
// 从文件中读取单例对象
File file = new File("Singleton.file");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Singleton newInstance = (Singleton) ois.readObject();
// 判断是否是同一个对象
System.out.println(newInstance == Singleton.getInstance()); // false
}两个对象地址不相等的原因是：readObject() 方法读入对象时，它必定会返回一个新的对象实例，必然指向新的内存地址。
五、枚举实现
**至此我们已经掌握了懒汉式与饿汉式的常见写法了，**在《大话设计模式》中的单例模式章节也止步于此。但是，追求极致的我们，怎么能够止步于此，在《Effective Java》书中，给出了终极解决方法，话不多说，学完下面，真的不虚面试官考你了。
在 JDK1.5 后，使用 Java 语言实现单例模式的方式又多了一种：枚举
我们先来看看枚举如何实现单例模式的，如下代码：
java
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("这是枚举类型的单例模式！");
}
}需要思考：使用枚举实现单例模式的优势在哪里？
我们从最直观的地方入手，第一眼看到这几行代码，就会感觉到"少"，没错，就是少，虽然这优势有些牵强，但写的代码越少，越不容易出错。
**优势1：**代码对比饿汉式与懒汉式来说，更加地简洁
其次，既然是实现单例模式，那这种写法必定满足单例模式的要求，而且使用枚举实现时，没有做任何额外的处理。
**优势2：**它不需要做任何额外的操作去保证对象单一性与线程安全性
我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。
我们可以简单地理解枚举实现单例的过程：在程序启动时，会调用Singleton的空参构造器，实例化好一个Singleton对象赋给INSTANCE，之后再也不会实例化
java
public enum Singleton {
INSTANCE;
Singleton() { System.out.println("枚举创建对象了"); }
public static void main(String[] args) { /* test(); */ }
public void test() {
Singleton t1 = Singleton.INSTANCE;
Singleton t2 = Singleton.INSTANCE;
System.out.print("t1和t2的地址是否相同：" + t1 == t2);
}
}
// 枚举创建对象了
// t1和t2的地址是否相同：true除了优势1和优势2，还有最后一个优势让枚举实现单例模式在目前看来已经是"无懈可击"了。
优势3 ：使用枚举可以防止调用者使用反射 、序列化与反序列化机制强制生成多个单例对象，破坏单例模式。
防破坏的原理如下：
（1）防反射
枚举类默认继承了 Enum 类，在利用反射调用 newInstance() 时，会判断该类是否是一个枚举类，如果是，则抛出异常。
（2）防止反序列化创建多个枚举对象
在读入Singleton对象时，每个枚举类型和枚举名字都是唯一的，所以在序列化时，仅仅只是对枚举的类型和变量名输出到文件中，在读入文件反序列化成对象时，利用 Enum 类的 valueOf(String name) 方法根据变量的名字查找对应的枚举对象。
所以，在序列化和反序列化的过程中，只是写出和读入了枚举类型和名字，没有任何关于对象的操作。
小总结：
（1）Enum 类内部使用Enum 类型判定防止通过反射创建多个对象
（2）Enum 类通过写出（读入）对象类型和枚举名字将对象序列化（反序列化），通过 valueOf() 方法匹配枚举名找到内存中的唯一的对象实例，防止通过反序列化构造多个对象
（3）枚举类不需要关注线程安全、破坏单例和性能问题，因为其创建对象的时机与饿汉式单例有异曲同工之妙。
总结：
（1）单例模式常见的写法有两种：懒汉式、饿汉式
（2）饿汉式：在类加载时已经创建好该单例对象，在获取单例对象时直接返回对象即可，不会存在并发安全和性能问题。
（3）懒汉式：在需要用到对象时才实例化对象，正确的实现方式是：Double Check + Lock，解决了并发安全和性能低下问题
（4）在开发中如果对内存要求非常高，那么使用懒汉式写法，可以在特定时候才创建该对象；
（5）如果对内存要求不高使用饿汉式写法，因为简单不易出错，且没有任何并发安全和性能问题
（6）为了防止多线程环境下，因为指令重排序导致变量报NPE，需要在单例对象上添加volatile关键字防止指令重排序
（7）最优雅的实现方式是使用枚举，其代码精简，没有线程安全问题，且 Enum 类内部防止反射和反序列化时破坏单例。