23种设计模式之单例模式

1.单例模式的应用场景
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛；例如，公司CEO、部门经理。J2EE标准中的ServletContext、ServletContextConfig 等、Spring框架应用中的ApplicationContext、数据库的连接池等也都说单例模式。

---

1.饿汉式单例模式
饿汉式单例模式在类加载时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没出西安以前就实例化了，不可能存在访问安全问题。
优点： 没有加任何锁、执行效率比较高，用户体验比懒汉式单例模式更好。
缺点： 类加载的时候就初始化，不管用与不用都占着空间，浪费了内存。
Spring中的IoC容器ApplicationContext 本身就是典型的饿汉式单例模式。
实例：
饿汉式单例模式：

//饿汉式单例模式
public class Hungry {
    //私有构造器
    private Hungry(){}

    private final static Hungry HUNGRY = new Hungry();

    //对外提供接口
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

饿汉式静态块单例模式：

//饿汉式静态块单例模式
public class HungryStaticSingleton {
    private  static final HungryStaticSingleton HUNGRY_STATIC_SINGLETON;
    
    private HungryStaticSingleton(){}
    
    static {
        HUNGRY_STATIC_SINGLETON = new HungryStaticSingleton();
    }
    
    public static HungryStaticSingleton getInstance(){
        return HUNGRY_STATIC_SINGLETON;
    }
    
}

---

2.懒汉式单例模式
特点： 被外部类调用的时候内部类才会加载。

//懒汉式单例模式
public class LazySimpleSingleton {

    private LazySimpleSingleton(){}

    private static LazySimpleSingleton lazy = null;
    
    private static LazySimpleSingleton getInstance(){
        if (lazy == null){
            lazy = new LazySimpleSingleton();
        }
        return lazy;
    }

}

存在问题： 可能会造成线程不安全。接下来解决问题：
通过synchronized解决线程安全问题，但仍然能通过反射来破坏单例模式。

//懒汉式单例模式  通过synchronized解决线程安全问题
public class LazySimpleSingleton {

    private LazySimpleSingleton(){}

    private static LazySimpleSingleton lazy = null;

    private static LazySimpleSingleton getInstance(){
        if (lazy == null){
            synchronized (LazySimpleSingleton.class){
                if (lazy == null){
                    lazy = new LazySimpleSingleton();
                    //1.分配内存给这个对象
                    //2.初始化对象
                    //3.设置lazy指向刚分配的内存地址
                }
            }
        }
        return lazy;
    }
}

---

3.静态内部类
这种形式兼顾饿汉式单例的内存浪费问题和synchronized 的性能问题，完美地屏蔽了这两个缺点。

//静态内部类
public class LazyInnerClassSingleton {
    private LazyInnerClassSingleton(){}
    
    public static final LazyInnerClassSingleton getInstance(){
        return lazyHolder.LAZY;
    }
    private static class lazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

---

4.演示通过反射来破坏单例

public class LazyInnerClassSingletonTest {
    public static void main(String[] args) {
        try {
            Class<?> clazz = LazyInnerClassSingleton.class;
            //通过反射获取私有的构造器
            Constructor c = clazz.getDeclaredConstructor(null);
            //强制访问
            c.setAccessible(true);
            //暴力初始化
            Object o1 = c.newInstance();

            Object o2 = c.newInstance();

            System.out.println(o1 == o2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

实验结果：

也就说明了创建两个不同的实例。
进一步修改： 在构造方法中做了一些限制，一旦出西安多次重复创建，则直接抛出异常。

public class LazyInnerClassSingleton {

    //如果没有使用，则内部类是不加载的
    private LazyInnerClassSingleton(){
        if (lazyHolder.LAZY != null){
            throw new RuntimeException("不允许创建多个实例");
        }
    }

    public static final LazyInnerClassSingleton getInstance(){
        return lazyHolder.LAZY;
    }
    private static class lazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

---

5.枚举式单例模式
枚举式单例模式是Effective Java书中推荐的一种单例模式实现写法。序列化和反射方法都不能破坏枚举式单例模式。

public enum  EnumSingle {

    INSTANCE;

    public EnumSingle enumSingle(){
        return INSTANCE;
    }
}

---

6.小结：
单例模式可以保证内存里只有一个实例，减少了内存的开销，海可以避免对资源的多重占用。