【23种设计模式】单例模式

一、饿汉式

类加载就会创建该单实例对象，存在内存浪费问题

1. 静态变量方式

public class Singleton {

    //私有构造方法
    private Singleton() {}
    
    //在成员位置创建该类的对象
    private static Singleton instance = new Singleton();
    
    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

2. 静态代码块方式

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

3. 枚举方式【推荐】

public enum Singleton {
    INSTANCE;
}

• 枚举类实现单例模式是极力推荐的一种方式
• 枚举类型是线程安全的，并且只会加载一次
• 枚举的写法非常简单，且是所有单例模式实现中唯一一种不会被破坏的

二、懒汉式

类加载不会创建该单实例对象，而是首次使用该对象时才会创建

1. 线程不安全

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        if (instance == null) {
            return new Singleton();
        }
        return instance;
    }
}

• 调用getInstance()方法获取Singleton类的对象时才创建，实现了懒加载效果
• 多线程环境，会出现线程安全问题

2. 线程安全

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            return new Singleton();
        }
        return instance;
    }
}

• 该方式既实现了懒加载，又解决了线程安全问题
• 但是加上synchronized关键字，会导致该方法执行效率特别低

3. 双重检查锁

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                //抢到锁之后再次判断是否为null
                if (instance == null) {
                    return new Singleton();
                }
            }
        }
        return instance;
    }
}

• 对于getInstance()方法来说，绝大部分操作都是读操作，读操作是线程安全的，因此无需让每个线程必须持有锁才能调用该方法
• 将加锁的时机进行调整，提高方法执行效率

4. 双重检查锁<改进版>【推荐】

public class Singleton {

    //私有构造方法
    private Singleton() {}

    //在成员位置创建该类的对象
    private static volatile Singleton instance;

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                //抢到锁之后再次判断是否为null
                if (instance == null) {
                    return new Singleton();
                }
            }
        }
        return instance;
    }
}

• 双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题
• 改进版使用volatile关键字，保证了可见性和有序性。避免在多线程环境中，出现空指针问题（出现原因：JVM在实例化对象时，会进行优化和指令重排序操作）

5. 静态内部类方式【推荐】

public class Singleton {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

• JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性
• 静态属性只会被初始化一次，同时静态属性按照顺序被初始化
• 静态内部类单例模式是一种优秀的单例模式，开源项目中较为常见
• 在没有加任何锁的情况下，保证了多线程下的安全，且没有任何性能影响和空间的浪费

三、单例模式被破坏的解决方案

除枚举方式无法被破坏外，其他方式都可被破坏

1. 序列化&反序列化

public class Singleton implements Serializable {

    //私有构造方法
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    //当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
    public Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

• 在Singleton类中添加readResolve()方法，在反序列化时被反射调用。如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象

2. 反射

public class Singleton implements Serializable {

    private static boolean flag = false;

    //私有构造方法
    private Singleton() {
        synchronized (Singleton.class) {
            //判断flag的值是否为true：如果是true，说明非第一次访问，直接抛出异常
            if (flag) {
                throw new RuntimeException("不能创建多个对象");
            }
            flag = true;
        }
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}