单例模式常见的五种实现方式

单例模式

单例模式常见的五种实现方式

饿汉式

类一初始化就会提前创建对象

1. 构造私有
2. 提供一个静态的成员变量，类型就是单例的类型，值就是创建的唯一实例
3. 静态变量不能直接访问，提供一个公共的静态方法，返回上面的静态成员变量

public class Singleton1 implements Serializable {
    //防止反射破坏单例
    private Singleton1(){
        if(INSTANCE!=null){
            throw new RuntimeException("单例对象不能重复创建！");
        }
    }
    private static final Singleton1 INSTANCE = new Singleton1();
    public static Singleton1 getInstance(){
        return INSTANCE;
    }
    //防止反序列化破坏单例
    private Object readResolve(){
        return INSTANCE;
    } 
}

反射破坏单例

反射默认通过无参构造创建对象，在构造方法中判断静态成员变量如果不为空，那么唯一实例就已经创建好了，就抛一个异常。

反序列化（实现了Serializable）

要写一个叫做readResolve()方法，返回唯一的静态实例。就不会用字节数组反序列化生成的对象。

枚举饿汉式

public enum Singleton2 {
    INSTANCE;

    //不写下面方法也能使用
    public static Singleton2 getInstance(){
        return INSTANCE;
    }
}

枚举类默认继承java.lang.Enum类，枚举类的构造器只能使用private权限修饰符（默认）。

其中每个枚举对象都是一个Singleton2对象，都是由public static final 修饰的。是在static代码块中创建。

反射和反序列化都不能破坏此单例，且线程安全。

懒汉式单例

调用getInstance()时创建对象，必须要考虑多线程情况下的

public class Singleton3 implements Serializable {

    private static Singleton3 INSTANCE=null;

    public static Singleton3 getInstance(){
        if(INSTANCE==null){
            return new Singleton3();
        }
        return INSTANCE;
    }
}

多线程情况下需要在方法上面加锁synchronized，但是性能会受到影响

只是在首次创建对象时，才需要控制只有1个线程拿到锁创建对象。

懒汉式单例DCL

DCL双检锁(Double-Check Locking )

在加锁之前先进行一次判断，实例是否已经创建，创建好了直接返回，没有就开始竞争锁，再判断对象是否创建，如果没有对象，再进行创建对象。

第二次判断是为了防止两个线程同时开始抢锁，创建完成对象之后，另一个拿到了锁再重复创建对象。

在静态成员变量上必须加上volatile（处理可见性，有序性），解决共享变量有序性问题

public class Singleton4 implements Serializable {
    private static volatile Singleton4 INSTANCE = null;
    public static Singleton4 getInstance(){
        if (INSTANCE == null){
            synchronized (Singleton4.class){
                if (INSTANCE == null){
                    INSTANCE = new Singleton4();
                }
            }
        }
        return INSTANCE;
    }
}

volatile起到的作用

在创建对象的时候经过了：new Singleton4()分配空间、调用Singleton4构造方法（对成员变量做初始化）、给静态变量INSTANCE赋值。----------后面两个不分先后

有可能在进行INSTANCE赋值的时候，进行了外部判断，这时候INSTANCE!=null，直接返回了INSTANCE，而这时候构造方法还没有执行，INSTANCE里面没有完整构造，可能使用的时候就会出现问题。

加上了volatile之后，会在赋值语句之后加上一个内存屏障，就会阻止语句的重排序，构造方法就不能越过屏障到赋值语句下面去。如果这时外部判断开始执行，那么INSTANCE还没赋值等于null，所以就会等拿到锁再执行后续语句。

内部类懒汉式单例

在内部类里面创建单例对象，并赋值给了静态变量，是在static静态代码块中进行的，所以创建过程是安全的。

public class Singleton5 implements Serializable {
    private static class Holder{
        static Singleton5 INSTANCE = new Singleton5();
    }
    private static Singleton5 getInstance(){
        return Holder.INSTANCE;
    }
}

了解jdk中哪些地方实现了单例模式

Collections集合工具类，经常需要获取一个空集合，就体现了单例模式的运用。