单例模式是24中设计模式中的最常用、也是最为简单的一种设计模式。java中实现单例模式的方式，大致分为两种：
1、构造方法+getInstance创建
2、内部类构造
3、枚举实现单例（推荐使用）
1、构造方法+getInstance创建方式
V1：最简单的代码实现方式：
//将类的构造函数写成private的，从而保证别的类不能实例化此类，然后再类中提供一个静态的实例并能够返回给使用者。
//这样，使用者就可以通过这个引用使用到这个类的实例了。
public class SingletonClass {
private static final SingletonClass instance = new SingletonClass();
public static SingletonClass getInstance(){
return instance;
}
//构造方法定义成private的，是为了防止其他类通过构造方法单独创建该类的对象。
private SingletonClass(){}
}
如上面的代码块，外部使用者如果需要使用SingletonClass的实例，只能通过getInstance()方法，并且类的构造方法是private的，这样就保证了这个类只能有一个对象。
V2：上面的代码虽然简单，但是有一个问题：无论这个类是否会被使用，在类加载的时候，都会实例化出来instance对象。如果创建这个对象比较耗时，比如需要连接100次数据库（有点夸张了），并且这个类还不一定会被使用到，那么就没有必要在类加载的时候创建无用的对象。 那么该怎么优化呢？
优化后的代码如下：
public class SingletonClass{
//去掉了final的修饰
private static SingletonClass instance = null;
public static SingletonClass getInstance(){
//增加对象是否为null的逻辑判断
if(null == instance){
instance = new SingletonClass();
}
return instance;
}
private SingletonClass(){}
}
代码优化点有两个地方：一是去掉instance的final修饰，将instance声明为可修改的变量。 二是在getInstance()方法中增加了instance对象的判空逻辑处理。
通过模拟代码流程，可以看出这部分代码的过程其实就是lazy loaded（懒加载）也就是延迟加载---直到使用的时候才进行创建加载。
V3：上面优化的代码，也很简单明白。单线程环境下，这段代码没有任何问题。但是多线程并发的场景下，就会有麻烦了。（想起了那句名言：“80%的错误都是由20%的代码优化造成的”）
来假设多线程的一个场景：线程A希望使用SingletonClass，调用了getInstance()方法。因为是第一次调用，A发现instance是null，于是就开始创建instance实例，就在这个时候，CPU发生时间片切换，线程B开始执行，B也要使用SingletonClass，也调用了getInstance()方法，此时也判断到instance是null --->注意，A判断到instance是null，但是并未完成创建对象的操作，此时B就开始了，并且B成功的创建出来对象。B创建完成后，切换到A继续执行，因为A已经判断为null了，所以A就直接创建了一个对象。 就这样，线程A和B各自拥有一个SingletonClass的对象 --- 单例模式失败！！！
解决方案就是加同步锁(synchronized)，优化代码如下：
public class SingletonClass{
//去掉了final的修饰
private static SingletonClass instance = null;
public synchronized static SingletonClass getInstance(){
//增加对象是否为null的逻辑判断
if(null == instance){
instance = new SingletonClass();
}
return instance;
}
private SingletonClass(){}
}
V4：上面的代码块，解决了功能和逻辑上的错误，无论是单线程、多线程的场景下，都会确保单例模式的成功。 但是，synchronized修饰的同步代码块，执行效率上会比较慢，如果多线程场景下，调用很多次getInstance()方法，即便无需创建对象也需要进行锁等待，那么性能问题就不得不考虑了！！
那么我们分析一下，是否有必要对整个方法加锁，是不是可以只针对某一块代码进行加锁，并且对加锁代码块的执行与否做一个if逻辑判断。这样就可以做到：并非所有调用getInstance()方法时都会进行加锁，只有需要创建对象的时候，才进行加锁操作，这样就会减少很多锁等待，提升性能。
public class SingletonClass{
//去掉了final的修饰
private static SingletonClass instance = null;
public static SingletonClass getInstance(){
//1、判断对象是否需要创建，无需创建就不用执行加锁的代码块（减少性能消耗）
if(null == instance){
//2、加锁同步代码块，应对多线程场景下单例模式失效的问题(参考V3版本)
synchronized(SingletonClass.class){
//增加对象是否为null的逻辑判断
if(null == instance){
instance = new SingletonClass();
}
}
}
return instance;
}
private SingletonClass(){}
}
首先判断instance是否为null，如果为null，加锁进行初始化；如果不为null，直接返回instance。
这就是double-checked locking设计实现的单例模式。
关于double-checked的设计,详细细节请参照：https://www.jianshu.com/p/a9ecac4bd753
V5：其实V4版本已经很完美了，但是java JVM有一个特性，不得不考虑。那就是JVM编译器的指令重排序。
试想一下，创建一个变量需要哪些步骤呢？ 1、申请一块内存。2、调用构造方法进行初始化操作。3、分配一个指针指向这快内存。 这3个步骤谁先谁后呢？JVM并么有规定，那么就存在这么一个情况，JVM先开辟出来一块内存，然后把指针指向这块内存，最后再调用构造方法初始化对象。
我们来设想这么一种场景：线程A开始创建SingletonClass实例，此时线程B调用了getInstance()方法，首先判断instance是否为null。按照我们上面说的内存模型（对象创建步骤），A已经把instance指向了那块内存，只是还没有调用构造方法，因此B检测到instance不为null，于是直接把instance返回了 ---- 问题出现了，尽管instance不为null，但它并没有被构造完成。如果B在A将instance构造完成之前就使用了这个实例，程序就会报错！！
如果解决这个问题，就用到了volatile关键字。注意哦：volatile关键字，只有在JDK1.5以及JDK1.5之后的版本中才能起作用，我们暂且讨论JDK1.5及以后版本的情况。
public class SingletonClass{
//去掉了final的修饰
private volatile static SingletonClass instance = null;
public static SingletonClass getInstance(){
//1、判断对象是否需要创建，无需创建就不用执行加锁的代码块（减少性能消耗）
if(null == instance){
//2、加锁同步代码块，应对多线程场景下单例模式失效的问题(参考V3版本)
synchronized(SingletonClass.class){
//增加对象是否为null的逻辑判断
if(null == instance){
instance = new SingletonClass();
}
}
}
return instance;
}
private SingletonClass(){}
}
注：volatile关键字本身包含“禁止指令重排序”的语义。所以instance被加上volatile关键字之后，其创建顺序就变得有序的了：先通过构造创建对象，再开辟空间，增加指针指向。
加上volatile关键字之后，就可以解决因为指令重排序造成的程序错误的情况。那么JKD1.5版本之前没有volatile关键字，应该怎么处理呢？或者有没有一个万能的解决办法，可以既简单有安全的实现单例模式？
那么，我们就开始讨论一下，创建单例模式的第二种方式：内部类构造
2、内部类构造方式
public class SingletonClass{
//私有静态内部类
private static class SingletonClassInstance{
private static final SingletonClass instance = new SingletonClass();
}
public static getInstance(){
return SingletonClassInstance.instance;
}
private SingletonClass(){}
}
说明：SingletonClass中并没有static属性的变量，所以不存在初始化。直到调用getInstance()方法，首先会加载SingletonClassInstance类，该类中有一个static的SingletonClass实例，并通过构造方法new出来一个新的对象，赋值给instance变量。然后getInstance()方法将该变量return给使用者。
由于内部类中instance是static、final的因此不会构造多次，且不允许修改。
由于SingletonClassInstance是私有静态内部类，所以不会被其他类所知道。同样static语义也要求不会有多个实例存在。并且，按照JSL规则，类的构造是原子的，非并发的，因此内部类不需要加同步块。同样，内部类的构造是非并发的，所以getInstance()方法也不需要加同步。
3、枚举实现单例模式
还有一种写法更简单，同时也能保证安全性、唯一性的写法：枚举类的方式
先看实现代码：
public enum SingletonE{
INSTANCE;
public void dosomethingMethod(){
//TODO do something...
}
}
相比上面实现，枚举的代码会更加简单。那么这种方式为什么是最好的呢？是因为枚举的实现方式本身可以帮助我们解决线程安全问题（主要是借助java底层实现的）。具体分析请参照《（设计模式）单例模式的枚举实现原理》
