设计模式 - 单例模式（懒汉、饿汉、双检锁、静态内部类）

什么叫单例模式

• 保证某个应用程序的某个示例有且只有示例

单例模式的应用场景

• 需求场景的对象只需要存在一份就足够，例如，连接池配置初始化

    /**
     * @功能: Redis JedisPool 连接池初始化
     */
    public static JedisPool getPool() {
        if (pool == null) {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(500);
            config.setMaxIdle(5);
            config.setMaxWaitMillis(1000 * 100);
            config.setTestOnBorrow(true);
            pool = new JedisPool(config,REDIS_IP,PORT,10000,AUTH_PASS);
        }
        return pool;
    }

单例模式 - 饿汉模式

• 加载类的时候就会加载对象
• 饿汉模式属于线程安全

/**
 * 1.将构造方法设为private，不允许外部直接访问
 * 2.使用类的成员变量创建该类的唯一实例该成员变量设为private,保证封装性
 *   该成员变量设为static,在类加载时就会创建实例，并且必须为static
 * 3.提供共有的静态方法作为外部获取该唯一实例的方式
 *   必须是static，外界不能创建实例只能通过类名调用静态方法
 **/
public class singleton(){
     pravite static singleton  instance = new singleton();

     public static singleton getInstance(){
         return instance;
     }

}

单例模式 - 懒汉模式

• 被实例化第一次调用才会去初始化
• 懒汉模式非线程安全
  从线程安全性上讲，不加同步锁的懒汉式是线程不安全的。
  假设开始线程0进入，判断instance为空，在将要创建实例时，cpu切换，
  线程1又进来了，同样instance为空 创建了实例，这是cpu切换回来到0线程，
  继续创建实例，这就会出现两个实例。
  所以为了安全使用饿汉模式，在类加载时创建实例，或者使用同步加锁

/**
 * 1、懒汉模式：与饿汉不同的是在创建唯一实例时不new初始化,而是第一次被调用才进行初始化
 *   a.将构造函数私有化；
 *   b.声明类的唯一实例，并且私有化；
 *   c.提供一个static修饰的方法获取当前类所创建的唯一的类实例。
 * 2、理解懒汉：在加载类的时候，只是声明一个引用，并没有实例化。
 *   只有第一次调用共有方法时才实例化。形象：不急切的，慵 懒的。
 **/
public Singleton2{
   //1.私有化构造方法
   private Singleton2(){
   }
   //2.创建私有类变量，区别与饿汉模式，不指向类的实例化
   private static Singleton2 instance;

   //3.获取该（单例）类的实例化
   public static Singleton2 getInstance(){
      //4.仅第一次加载时初始化
      if(instance==null){
        instance = new Singleton2();
      }
      return instance;
   }
}

• 懒汉模式 双重检查锁

/**
 * 懒汉模式 - 双重检查锁
 */

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

• 懒汉模式 - 静态内部类

/**
 * 懒汉模式 - 静态内部类
 */ 
public class Singleton {  
    //将构造函数私有化
    private Singleton (){}  
    //这种方式利用了classloder的机制来保证初始化INSTANCE时只有一个线程
    //Singleton类被装载了，instance不一定被初始化
    //因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，
    //才会显示装载 SingletonHolder类，从而实例化instance。
    private static class SingletonHolder {  
     private static final Singleton INSTANCE = new Singleton();  
    }  
  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}