java设计模式——单例模式

单例设计模式及其多种实现方法

介绍

单例设计模式属于创建型模式（其他还有 工厂方法模式 抽象工程模式 原型模式 建造者模式 ）
涉及到单一的类 该类负责创建自己的对象且确保只有单个对象被创建 可以直接访问该对象，使用者不需要实例化 多次使用的都是同一个地址的对象（instance1 == instance2）

实现方法

• 饿汉式：
  • 优点是线程安全，类初始化时就完成实例的创建，以后调用getInstance方法获取对象实例时速度比较快
  • 缺点是会造成类初始化过程变慢，还可能会提前初始化单例类

1 静态成员变量（饿汉式）

类加载的时候就已经创建 后续直接使用 而且无论是否使用 对象都已经存在了

public class Singleton {
    //私有构造方法 不让外部创建
    private Singleton(){
    }
    //在本类中创建本类对象  类加载的时候 instance 就已经创建
    private static Singleton instance = new Singleton();
    //提供一个公共的访问方式 用于获取对象
    public static Singleton getInstance(){
        return instance;
    }
}

public class Test {
    public static void main(String[] args) {
        //创建singleton类的对象 类名调用静态方法
        Singleton instance = Singleton.getInstance();
        System.out.println(instance);
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance1);
        //输出相同
    }
}

2 静态代码块（饿汉式）

和静态成员变量形式没区别

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

3 双重检查锁（DCL）+volatile关键字（懒汉式） 单例 线程安全 指令有序

懒汉 在用的时候才创建对象 而且内部判断一下如果已经存在 直接使用 不创建新的
但是可能会出现线程安全的问题 多个线程并发同时创建多个对象 用双重检查锁 保证线程安全
锁需要锁得细化一点 保证性能
针对读操作不加锁 写操作才加锁

public class Singleton {
    //私有构造方法
    private Singleton(){
    }
   private static volatile Singleton instance;//volatile保证指令是有序的 避免指令排序带来的空指针异常
    public static Singleton getInstance(){
        //单例 先判断对象是否存在  不存在才会创建该对象
        if (instance == null) {//第一重检查 对于已存在的情况（绝大多数）进不到里面 不用获取锁
            //创建对象
            // （存在线程不安全问题 线程1 进入 判断不存在 此时线程2进入 也发现不存在 1 2 都创建了对象）
            //应该加锁 双重检查锁
            synchronized (Singleton.class){
                //第二次检查 对于同时判断为null 的 并发线程（对象不存在时） 才加锁进行对象创建
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

为什么要双重检查锁+volatile

答：
除了第一次获取单例外，其余都是读取 进行第一次判断instance==null 可以让读取的 直接获取到单例
当发现还未创建单例对象时候，可能有多个线程同时判断为null 这是就需要加锁 保证只有一个线程在创建对象。
当线程创建完毕 其他强到锁的对象 进去后也要再次判断别人是不是已经创建好了 不然 会重复创建
【为什么用volatile】instance= new Singleton() 这句代码其实是三个操作
1 在堆上开辟空间
2 在堆上初始化对象
3 引用指向 堆内存
但是 jvm会进行指令重排序 如果是 132 到3 的时候 已经指向 但是instance！=null了 就会导致其他线程认为 已经创建完毕（其实是半成品 ）从而返回错误的instance
而且 volatile保证对象都是从主存上读取 （线程是 复制主存的内容 然后修改 修改完成传给主存 如果从主存上读取 就能保证是初始化完成的正确实例对象）

4 静态内部类（懒汉式）

利用静态内部类的特性 只有内部类的成员被调用才会加载该内部类

public class Singleton {
    private Singleton(){
    }
    //静态内部类在外部类被加载过程中，不会被加载（保证懒汉）只有内部类的属性/方法被调用才会加载
    // 而且static保证只被实例化一次 保证实例化顺序
   private static class SingletonHolder{
        private final static Singleton INSTANCE = new Singleton();
   }
    //调用该方法的时候才会加载内部类 且后续再次调用也不会重新创建对象
    public  static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

5 枚举类（懒汉式）

枚举天生线程安全 任何情况下都是单例
这是实现单例最好的方式

//枚举类型 线程安全 只会装载一次 极力推荐
public enum Singleton {
    INSTANCE;
}

public class Test {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance == instance1);//返回true
    }
}

6 使用容器实现

针对多种类型的单例 通过容器集中管理

public class SingletonManager extends Staff {
    private static Map<String, Object> mServices = new HashMap<>();
    
    private SingletonManager(){}
    
     public static void registerService(String key, Object instance){
         //加入了一个判断处理，避免重复添加
        if(!mServices.containsKey(key)){
            mServices.put(key, instance);
        }
    }
    
    public static Object getService(String key){
        return mServices.get(key);
  }