设计模式之单例模式

1 饿汉式

1.1 静态常量

这种单例模式可用，可能造成内存浪费

class Singleton{

    private final static Singleton instance = new Singleton();

    private Singleton(){

    }

    public static Singleton getInstance(){

        return instance;
    }


}

• 优点：这种写法简单，在类装载的时候就完成实例
• 缺点：在类装载的时候就完成实例化，。如果从始至终从未使用过这个实例，则会造成内存的浪费

1.2 静态代码块

这种单例模式可用，但是可能造成内存浪费

class Singleton{

    private static Singleton instance;

    static{
        instance = new Singleton();
    }
    
    private Singleton(){

    }

    public static Singleton getInstance(){
        return instance;
    }
}

2 懒汉式

2.1 线程不安全懒汉式

不推荐使用

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    public static Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

• 单线程安全
• 多线程不安全

2.2 线程安全同步方法

不推荐使用,效率太低

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }


    //每一次调用时都要进行同步，效率太低
    public static synchronized Singleton getInstance(){

        if(instance == null)
            instance = new Singleton();
        return instance;

    }

}

3 双重检查

推荐使用

class Singleton{

    private  static volatile Singleton instance;

    private Singleton(){

    }

    public static  Singleton getInstance(){
        if(instance == null)
            synchronized (Singleton.class){
                if(instance == null)
                    instance = new Singleton();
            }

        return instance;
    }
}

3.1 提问

（1）同步为何不用 public synchronized static SingletonClass getInstance()，也就是说为何不同步这个方法，而要同步下面的语句：

因为synchronized修饰的同步块可是要比一般的代码段慢上几倍，如果经常调用getInstance,那么性能问题就得考虑了。因为只有第一次才需要锁 后面new 后 不需要锁 直接return

（2）最外层为何要有if (instance == null)判断：

因为我们在（1）中，发现依旧存在着性能问题，也就是说，只要getInstance方法被调用，那么就会执行同步这个操作，于是我们加个判断，当instance没有被实例化的时候，也就是需要去实例化的时候才去同步。

（3）里层为何还需要if (instance == null)判断：

因为我们第一个判断是在同步块外面。假如里面没有判断，假设一个场景：线程A在第一个判断后获取锁之前切换到了线程B，线程B获取锁后执行初始化，再切换到线程A，线程A再去初始化，这就初始化两次了。

（4）instance为何要有volatile 修饰
instance = new Singleton();一共有三步
1.在内存中开辟一片内存区域
2.在这片内存区域中执行构造函数，实例化对象
3.instance引用指向这片内存区域。

假设instance变量没有用volatile关键字修饰，A、B两线程并发访问DCL.class的getInstance()方法，A先执行(时间上)。当线程A执行到"此"处，上述3步操作可能被指令重排序为1->3->2，当线程执行了"3"，还未执行"2"或"2"未完全执行完，此时 instance 不再是null(instance所指向区域已分配内存)。若此时轮到了线程B的时间片，B在"甲"处判断instance非空，就将instance返回了，而此时instance所指向的对象并未实例化或并未完全实例化，必将发生错误。

如果instance变量用volatile修饰，有两层效果：

1. 禁止指令重排序优化：即不会出现指令执行顺序为1->3->2的情况，只能是1->2->3。当线程B执行到此处，instance要么为null，要么指向已完全初始化了的对象(内存区域)。

2. 保证instance变量的可见性
   由于可见性问题，线程T1在自己的工作线程内创建了实例，但此时还未同步到主内存中，此时线程T2判断INSTANCE还是null，那么线程T2又将在自己的工作线程创建一个实例，这样就创建了多个实例

4 静态内部类

推荐使用

//静态内部类，推荐使用，jvm虚拟机只加载一次Singleton类，里面的静态内部类也只加载一次
class Singleton{
    private Singleton(){

    }
    //当Singleton类进行类装载时，静态内部类不会进行装载,只有内部类才可以访问构造函数
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInsatnce(){

        //此时静态内部类装载，类装载是线程安全的，而且只会一次
        return SingletonInstance.INSTANCE;
    }
}

5 枚举

推荐使用，不仅可以解决线程同步还可以防止反序列化，因为枚举类没有构造函数

enum Singleton{
    INSTANCE;
}

单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)