设计模式——单例模式

单例模式

定义

单例模式指的是一个类只有一个实例化对象.该实例化对象是该类的一个属性,该类对外只提供一个公共的getInstance方法.其他类在获取该类的实例对象时获取到的都是同一个实例对象.
单例模式分为饿汉式和懒汉式.饿汉式指的是在类初始化的时候就对该实例对象进行初始化;懒汉式指的是实例对象在被使用的时候才被初始化.二者的区别在于初始化的时机不同

实现方式

单例模式的实现方式可以分为3个步骤

1. 将构造器私有化
2. 在类内部创建实例对象
3. 初始化该实例对象

饿汉式-静态常量

该实现方式指的是在创建该实例对象时就通过new的方式来初始化该实例对象

public class SingletonTest {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2); // true
        System.out.println(instance1.hashCode() == instance2.hashCode()); // true
    }
}
class Singleton{
    private final static Singleton instance = new Singleton();
    private Singleton(){

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

饿汉式-静态代码块

该创建方式就是在创建实例对象后,通过在静态代码块来初始化该实例对象

public class SingletonTest {

    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.getClass() == instance2.getClass());
    }

}
class Singleton{
    private static Singleton instance;
    private Singleton(){

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

懒汉式-双重检验

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;
    }
}

双重检验指的是两次判断if(instance == null).这里来详细解释一下双重检验中的每层含义

1. 为什么需要加锁
   加锁的根本原因在于if(instance == null)的语句块不是原子性的操作.这个语句块的执行流程是首先工作内存从主内存中拿到instance变量,然后判断变量是否为null,如果为null则将instance指向新的对象,然后将instance写会到主内存.
   如果不加锁,线程1在拿到为null的instance后,线程2在线程1写回主内存之前同样从主内存中拿到了为null的instance,因此instance就被实例化了2次,在多线程环境下就可能会导致每个线程独自创建1个instance的实例对象,因而破坏了单例模式的本义.
   加锁能够保证在同一时刻执行if语句块的只能有1个线程.

2. 为什么需要双重检验
   在多线程环境下,instance对象其实只需要被实例化一次,当实例化后,其他的线程在调用getInstance方法后就会直接返回instance.如果没有双重校验,那么每个线程在执行getInstance方法时都会去创建锁和释放锁,造成了不必要的资源浪费.
   当加入第二重if校验后就可以避免锁资源的浪费

3. 为什么需要volatile关键字
   volatile关键字主要是防止instance = new Singleton()这条语句被编译器进行指令重排序的优化.首先volatile关键字具有禁止指令重排序的功能.
   首先我们来分析一下instance = new Singleton()这条语句的执行流程

   1. 在堆上创建对象需要的空间,执行类加载
   2. 进行初始化
   3. 将栈上的对象引用指向堆上的实例对象

   编译器在执行指令重排序时会把2,3两步的顺序颠倒,颠倒后在多线程的环境下会发生异常.
   假设线程1在执行该实例化语句时发生了指令重排序,在执行2,3两步之间线程2调用了getInstance方法执行最外层的if检验,由于此时线程1已经将栈上的对象引用指向了堆上的实例对象(但未初始化),所以线程2会直接跳过if判断返回instance,而线程2返回的instance是未初始化的,所以会抛出异常.
   通过使用volatile关键字来禁止指令重排序从而保证线程安全

懒汉式-静态内部类

该创建方式利用的是静态内部类在JVM中的加载机制来保证线程的安全.静态内部类在执行类加载时只会执行一次,且会在被调用时才会执行类加载(实现了懒加载)

class Singleton{
    private Singleton(){

    }

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

懒汉式-枚举

该创建方式利用的是枚举的创建机制来保证单例和线程安全.不过该创建方式的缺点是无法实现懒加载(枚举会在类加载的时候初始化).但枚举有枚举独特的优势,上述单例模式的实现方式在一定程度上都是不安全的,可以通过反射来从运行时动态获取到类信息从而创建实例对象.而反射在遇到枚举时会抛出异常.所以枚举式单例模式更加安全

class Singleton{
    private Singleton(){

    }

    private enum SingletonInstance{
        INSTANCE;
        private static final Singleton instance = new Singleton();

        private Singleton getInstance(){
            return instance;
        }
    }
    public static  Singleton getInstance(){
        return SingletonInstance.INSTANCE.getInstance();
    }
}