概念

单例模式是一种对象的创建模式，它用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例.

优点

1.对于频繁使用的对象，可以省略创建对象所花费的时间，对于那些重量级的对象而言，是一笔非常可观的系统开销.
2.由于new操作的次数减少，因而对系统内存的使用频率也会降低，减轻GC的压力和缩短GC的停顿时间.

一.立即加载/“饿汉模式”

立即加载就是使用类的时候已经将对象创建完毕（不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故又被称为“饿汉模式”），常见的实现办法就是直接new实例化。

public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static、final修饰
    private static final Singleton instance = new Singleton();
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        return instance;
    }
}

优点：

实现起来简单，没有多线程同步问题。

缺点：

当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

二.延迟加载/“懒汉模式”

延迟加载就是调用get()方法时实例才被创建（先不急着实例化出对象，等要用的时候才给你创建出来。不着急，故又称为“懒汉模式”），常见的实现方法就是在get方法中进行new实例化。

public class Singleton {
    // 将自身实例化对象设置为一个属性，并用static修饰
    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：

实现起来比较简单，当类SingletonTest被加载的时候，静态变量static的instance未被创建并分配内存空间，当getInstance方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存。

缺点：

在多线程环境中，这种实现方法是完全错误的，无法同步，根本不能保证单例的状态。

三.线程安全的“懒汉模式”

public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    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(instance == null) {
                  instance = new Singleton();
              }
          }
           return instance;
      }

优点：

在多线程情形下，保证了“懒汉模式”的线程安全。

缺点：

众所周知在多线程情形下，synchronized方法通常效率低，显然这不是最佳的实现方案。

四.DCL双检查锁机制

public class Singleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static volatile Singleton instance=null;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        // 第一次检查instance是否被实例化出来，如果没有进入if块
        if(instance == null) {
            synchronized (Singleton.class) {
                // 某个线程取得了类锁，实例化对象前第二次检查instance是否已经被实例化出来，如果没有，才最终实例出对象
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

缺点：

JVM的即时编译器中存在指令重排序的优化
解决办法：
1.使用volatile ，可见性，避免指令重排。
2.静态内部类/枚举

五.静态内部类

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

优点：

1.JVM本身的机制保证了线程安全/没有性能缺陷
2.没有使用synchronized 关键字，性能优势
3.SingletonHolder 是私有的，无法从外部访问

六.枚举

public enum EasySingleton{
    INSTANCE;
}

优点:

简单，线程安全