java单例模式（Holder模式美滋滋）

饱汉模式(懒汉模式)

 // 饱汉
  // 非线程安全
  public class Singleton1 {
    private static Singleton1 singleton = null;
    private Singleton1() {
    }
    public static Singleton1 getInstance() {
      if (singleton == null) {
        singleton = new Singleton1();
     }
     return singleton;
  }
 }

优点：懒加载启动快，资源占用小，使用时才实例化，无锁。

缺点：非线程安全。

饱汉模式(懒汉模式)–线程安全

 public class Singleton {
  
      /**
       * 定义一个变量来存储创建好的类实例
       */
  
      private static Singleton uniqueInstance = null;
  
     /**
      * 私有化构造方法，好在内部控制创建实例的数目
      */
 
     private Singleton(){
     }
 
     /**
      * 定义一个方法来为客户端提供类实例
      * @return 一个Singleton的实例
      */
 
     public static synchronized Singleton getInstance(){
 
         //判断存储实例的变量是否有值
         if(uniqueInstance == null){
             //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
             uniqueInstance = new Singleton();
         }
 
         //如果有值，那就直接使用
         return uniqueInstance;
     }
 
     /**
      * 示意方法，单例可以有自己的操作
      */
 
     public void singletonOperation(){
 
 //功能处理
 
     }
 
     /**
      * 示意属性，单例可以有自己的属性
      */
 
     private String singletonData;
 
     /**
      * 示意方法，让外部通过这些方法来访问属性的值
      * @return 属性的值
      */
 
     public String getSingletonData(){
 
         return singletonData;
 
     }
 
 }            

优点：同上，但加锁了。

缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。

饱汉模式(懒汉模式)–双重加锁检查DCL（Double Check Lock）

public class Singleton {
  
      /**
       * 对保存实例的变量添加volatile的修饰
       */
  
      private volatile static Singleton instance = null;
 
      private Singleton(){
 
     }
 
     public static Singleton getInstance(){
 
 //先检查实例是否存在，如果不存在才进入下面的同步块
 
         if(instance == null){
 
 //同步块，线程安全的创建实例
 
             synchronized(Singleton.class){
 
 //再次检查实例是否存在，如果不存在才真的创建实例
 
                 if(instance == null){
 
                     instance = new Singleton();
 
                 }
 
             }
 
         }
 
         return instance;
 
     }
 
 }

优点：懒加载，线程安全。

注：实例必须有 volatile 关键字修饰，其保证初始化完全。

饿汉模式

public class Singleton {
  
  //4：定义一个静态变量来存储创建好的类实例
  
  //直接在这里创建类实例，只会创建一次
  
      private static Singleton instance = new Singleton();
  
 //1：私有化构造方法，好在内部控制创建实例的数目
 
     private Singleton(){
 
     }
 
 //2：定义一个方法来为客户端提供类实例
 
 //3：这个方法需要定义成类方法，也就是要加static
 
 //这个方法里面就不需要控制代码了
 
     public static Singleton getInstance(){
 
 //5：直接使用已经创建好的实例
 
         return instance;
 
     }
 
 }

优点：饿汉模式天生是线程安全的，使用时没有延迟。

缺点：启动时即创建实例，启动慢，有可能造成资源浪费。

Holder模式(推荐)

public class Singleton {
      /**
       * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
       * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
       */
      private static class SingletonHolder{
          /**
           * 静态初始化器，由JVM来保证线程安全
           */
         private static Singleton instance = new Singleton();
     }
     /**
      * 私有化构造方法
      */
     private Singleton(){
     }
     public static  Singleton getInstance(){
         return SingletonHolder.instance;
     }
 }

优点：将懒加载和线程安全完美结合的一种方式（无锁）。（推荐）

备注：

1. 全局共享，独一份；

2. 构造函数不暴露（如果暴露便不能保证一份），自己负责自己的构造；

3. 懒汉式：Lazy load，用到才加载，非线程安全。如何保证线程安全呢：

（1） synchronized getInstance()。

（2）双重检查加锁（volatile）。

4. 饿汉式：一开始就申请好，浪费了点资源，但其线程安全。

5. Holder模式：

（1）改成内部类，由JVM保证线程安全性。