单例模式是23种中最基础也是最简单的。

单例模式分两大类，懒汉式和饿汉式。大家看到其他的资料写6、7种的都是由这两种拓展的，并且拓展出来的有很多都是不建议使用的，所以本文我所先列出推荐使用的，然后后面我写出反例，并解释原因。

懒汉式单例模式：在类加载时不初始化。
饿汉式单例模式：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快。
这里让读者很好的区分什么懒什么饿做一个比喻：单例模式最终的目的是实例化一个唯一的对象，那么懒的意思就是虚拟机加载我时我也不初始化，我就等你调用我的时候我才new，所以懒。饿的意思是，这种方式很饥渴，想马上得到对象，所以虚拟机加载的时候就马上把对象new出来，等着被调用就可以了。

【饿汉式】
饿汉式第一种（静态常量），使用static修饰当jvm启动时就已经实例化了。

public class Singleton {
 
    private final static Singleton INSTANCE = new Singleton();
 
    private Singleton(){}
 
    public static Singleton getInstance(){
        return INSTANCE;
    }

饿汉式第二种（静态代码块） ，与上面的没啥区别就是写法不同。

public class Singleton {
 
    private static Singleton instance;
 
    static {
        instance = new Singleton();
    }
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        return instance;
    }
}

【懒汉式】
懒汉式第一种，当多个线程同时执行if (singleton == null)时，便产生多个实例，因此线程不安全，不可以使用。

public class Singleton {
 
    private static Singleton singleton;
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉式第二种，保证了线程安全，却因为效率太低不到万不得已不可以使用。

public class Singleton {
 
    private static Singleton singleton;
 
    private Singleton() {}
 
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉式第三种，两个线程都进入getInstance方法时，一条通过了(singleton == null) ，一条正在执行，那么也会产生多个实例，因此线程不安全，不可以使用。

public class Singleton {
 
    private static Singleton singleton;
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

懒汉式第四种（静态内部类）强烈推荐使用，类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，也能保证只在使用的时才实例化。

public class Singleton {
 
    private Singleton() {}
 
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

懒汉式第五种（双重检查加锁DCL）。

这里解释一下双重检测加锁，顾名思义，就是对变量进行多次判断，并使用同步，这种做法可以做到线程安全，但是效率并不高。使用双重检查操作的变量必须是volatile声明的，引用《Java并发编程实战》一句话：“volatile变量读取操作对性能通常只是略高于非volatile变量读取操作的性能。然而，DCL的这种使用方法已经被广泛的废弃了，因而它不是一种高效的优化措施。”

所以本人见解，DCL不推荐使用。

这也跟许多博客说的有差异，不过看过这本《Java并发编程实战》后你就会理解我说的话了。

public class Singleton {
 
    private static volatile Singleton singleton;
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

【枚举】
这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

还有一点需要说明，枚举类在jvm启动时便加载，而且枚举类里的变量最后实际都是被编译为静态变量了，Java中静态变量都是存储在Method Area。

public enum Singleton {
    instance;
    public void whateverMethod(){
    }
}

由此可见，使用饿汉式是最安全最方便的方式，如果使用懒汉式，强烈建议使用静态内部类方式，无论在性能和线程安全都做都很好。