单例模式，是一种常用的软件设计模式，其主要作用是保证某一个类只能有一个该类的实例。解决的问题就是一个全局使用的类频繁地创建与销毁。在当您想控制实例数目，节省系统资源的时候您就可以使用到它了。
单例模式有三个要点：
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。
下面我就详细介绍下单例的六种写法与其各自的特点：
饿汉/懒汉/懒汉线程安全/DCL/静态内部类/枚举
1. 饿汉模式单例
首先上代码：
public class HungurySingleton{
private static final HungurySingleton mHungurySingleton=new HungurySingleton();
private HungurySingleton(){}
public static HungurySingleton getInstance(){
return mHungurySingleton；
}
}
代码比较简单，首先声明私有的构造方法，这样保证其它类不能直接构造该类的实例。然后在类中创建该类的私有实例，最后创建外部的接口获取该实例。
注意：保证创建该类的私有实例与获取接口都必须是静态的。
不足：因为是静态的，所以JVM虚拟机就会在任何需要使用到该单例时都会被创建，不能对实例做延时加载。
优化：懒汉模式。
2.懒汉模式
首先上代码：
public class LazySingleton{
private static LazySingleton mLazySingleton;
private LazySingleton(){}
public static LazySingleton getInstance(){
//第一次创建时候初始化
if(mLazySingleton==null){
mLazySingleton=new LazySingleton();
}
return mLazySingleton；
}
}
如上代码所示，我们不再一开始就进行实例的创建，而是在需要使用到该实例的时候才创建，这样就解决了饿汉模式下的缺点。但熟悉Java多线程都知道，这样的实现是无法保证在多线程的情况下实例是唯一的。
不足：无法保证在多线程并发的情况下实例是唯一的。多线程下，懒汉模式是失效的。
优化：懒汉线程安全模式。
3.懒汉线程安全模式
首先上代码：两种方式
public class LazySafeSingleton{
private static LazySafeSingleton mLazySafeSingleton;
private LazySingleton(){}
public static LazySingleton getInstance(){
//同步代码块实现
synchronized(LazySingleton.class){
if(mLazySingleton==null){
mLazySafeSingleton=new LazySafeSingleton();
}
}
return mLazySingleton；
}
}
public class LazySafeSingleton{
private static LazySafeSingleton mLazySafeSingleton;
private LazySingleton(){}
//方法名中声明synchronized关键字
public static synchronized LazySingleton getInstance(){
if(mLazySingleton==null){
mLazySafeSingleton=new LazySafeSingleton();
}
return mLazySingleton；
}
}
这样保证了线程安全。
不足： 它会有性能上的缺陷，由于使用了synchronized关键字
优化： DCL模式
4.DCL模式单例
又称双重检验锁机制，首先上代码：
public class LazySafeSingleton{
private static LazySafeSingleton mLazySafeSingleton;
private LazySingleton(){}
public static LazySingleton getInstance(){
//同步代码块实现
if(mLazySingleton==null){
synchronized(LazySingleton.class){
if(mLazySingleton==null){
mLazySafeSingleton=new LazySafeSingleton();
}
}
}
return mLazySingleton；
}
}
这种模式使用同步块加锁的方法解决懒汉安全模式的性能问题，它会有两次检查mLazySingleton是否为空。
不足： mLazySafeSingleton=new LazySafeSingleton(); 使用new创建实例不是一个原子操作。（具体什么是原子操作，我也不知道）
这句代码的逻辑是：第一步给实例分配内存，第二步使用New关键字，调用构造方法实例化我们的对象，第三步将我们的对像指向分配的内存空间。但我们的JVM的虚拟机存在指令重排序的优化。什么意思呢，就是上述三个步骤不一定会按照这个一二三步骤顺序执行。这时候会造成线程不安全，报错。
解决办法：将实例变量设置为volatile
private static volatile LazySafeSingleton mLazySafeSingleton;
volatile可以禁止JVM的指令重排序的优化。
5.静态内部类模式单例
首先上代码：
public class StaticInnerSingleton{
private StaticInnerSingleton(){}
public static StaticInnerSingleton getInstance(){
return Holder.mStaticInnerSingleton;
}
//静态内部类
private static class Holder{
private static final StaticInnerSingleton mStaticInnerSingleton=new StaticInnerSingleton();
}
}
JVM提供给我们提供同步控制：static 与 final。它们修饰的变量具有线程安全的特性。在内部类中创建我们的实例，只要我们不使用这个内部类，就不会加载该内部类，就不会创建我们需要的实例。只有我们第一次调用getInstance()这个方法时，才会加载内部类并初始化类的对象。这样能确保线程安全同时能确保类的唯一性。
这种方式是我们比较推荐的创建单例模式的方式。
优点： 利用类中静态变量的唯一性。
- JVM本身的机制保证了我们线程的安全。
- 没有使用synchronized关键字，提升了我们的性能。
- Holder是私有的，除了getInstance()方法，外部没有其它方法可以访问。
6.枚举
首先上代码：
public enum EnumSingleton{
INSTANCE; //定义一个枚举单元，这就是一个实例
public void doSomething(){
...
}
}
代码相较于静态内部类的形式还要少。这是一个大优点。
当然这里可以再添加一些实例，或一些实例方法。但需要注意的是，当只有一个枚举单元时，这个实例是线程安全的，如果添加了其它的实例，就必须要保证它们是线程安全的操作。
优点：代码写法简单。
以上，就是所有单例的所有表达方法。
总结：
饿汉：无法对instance进行延迟加载
懒汉：多线程并发下无法保证实例的唯一性
懒汉线程安全：使用synchronized关键字导致性能缺陷
DCL：JVM编译器的指令重排序
静态内部类/枚举：延迟加载，线程安全，性能优势
