单例模式

单例模式是一种用来保证一个对象只能创建一个实例的创建型模式

引言-面向对象设计原则

单一职责原则
开闭原则
里氏替换原则
接口隔离原则
依赖倒置原则
迪米特原则

什么是单例模式

顾名思义，用来保证一个对象只能创建一个实例。
这种模式属于创建型模式

单例模式的特点

单例类只能有一个构造函数,并且是私有的
单例类必须自己创建自己的唯一实例
单例类必须给所有其他对象提供这一实例。

单利模式的优缺点

优点:在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
缺点:没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

实现单例模式的方式

(1)饿汉式单例
<1> 优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
<2>缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能占着茅坑不拉shi

public class HungrySingleton {
	//私有的构造函数
    private HungrySingleton() { }
    //自己创建自己的实例
    private static final HungrySingleton hungrySingleton = new HungrySingleton();
    //向其他对象提供这一实例
    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

(2)懒汉式单例
<1>优点：延迟加载 <1>缺点：线程不安全，必须加锁 synchronized 才能保证单例，但加锁会影响效率。

public class LazySimpleSingleton {
    //私有的构造函数
    private LazySimpleSingleton() {}

    private static LazySimpleSingleton lazy = null;
    //实例化对象并提供这一实例
    public static LazySimpleSingleton getInstance() {
        if (lazy == null) {
            lazy = new LazySimpleSingleton();
        }
        return lazy;
    }
}

(3)双重检查锁单例 <1>优点：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class LazyDoubleCheckSingleton {

    private volatile static LazyDoubleCheckSingleton lazy = null;

    private LazyDoubleCheckSingleton() { }

    public static LazyDoubleCheckSingleton getInstance() {
        if (lazy == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (lazy == null) {
                    lazy = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazy;
    }
}

(4)静态内部类单例
<1>延迟加载(使用的时候才会实例化),避免项目启动内存的消耗
<2>内部类一定是在方法调用之前初始化，巧妙地避免了线程安全问题

public class LazyInnerClassSingleton implements Serializable {
    // 私有的构造方法
    private LazyInnerClassSingleton(){}
    // 公有的获取实例方法
    public static final LazyInnerClassSingleton getInstance(){
        return LazyHolder.LAZY;
    }
    // 静态内部类
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

如何破坏单例？

(1)反射
<1>破坏静态内部类单例

public static void main(String[] args) {
        try {
            //很无聊的情况下，进行破坏
            Class<?> clazz = LazyInnerClassSingleton.class;
            //通过反射拿到私有的构造方法
            Constructor c = clazz.getDeclaredConstructor(null);
            //因为要访问私有的构造方法,这里要设为true,相当于让你有权限去操作
            c.setAccessible(true);
            //暴力初始化
            Object o1 = c.newInstance();
            //调用了两次构造方法，相当于 new 了两次
            Object o2 = c.newInstance();
            //这里输出结果为false
            System.out.println(o1 == o2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

输出为假，说明内存地址不同，就是实例化了多次，破坏了单例模式的特性。

<2>防止反射破坏单例模式

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

多次创建抛出异常

java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.cl.singleton.LazySingletonTest.main(LazySingletonTest.java:68)
Caused by: java.lang.RuntimeException: 只能实例化1个对象
	at com.cl.singleton.LazyInnerClassSingleton.<init>(LazyInnerClassSingleton.java:18)
	... 5 more

(2)序列和反序列化 <1> 序列化破坏单例模式

	//序列化创建单例类
    public static void main(String[] args) {
        LazyInnerClassSingleton s1 = null;
        //通过类本身获得实例对象
        LazyInnerClassSingleton s2 = LazyInnerClassSingleton.getInstance();
        FileOutputStream fos = null;
        try {
            //序列化到文件中
            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();
			//从文件中反序列化为对象
            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (LazyInnerClassSingleton) ois.readObject();
            ois.close();
            //对比结果,这里输出的结果为false
            System.out.println(s1 == s2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

结果为假，说明也破坏了单例模式

<2>防止序列化破坏单例模式

public class LazyInnerClassSingleton implements Serializable {

    private static final long serialVersionUID = -4264591697494981165L;

    // 私有的构造方法
    private LazyInnerClassSingleton(){
        // 防止反射创建多个对象
        if(LazyHolder.LAZY != null){
            throw new RuntimeException("只能实例化1个对象");
        }
    }
    // 公有的获取实例方法
    public static final LazyInnerClassSingleton getInstance(){
        return LazyHolder.LAZY;
    }
    // 静态内部类
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
    // 防止序列化创建多个对象,这个方法是关键
    private  Object readResolve(){
        return  LazyHolder.LAZY;
    }

}

单例模式的最佳实践–枚举

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

经验

一般情况下，不建议使用懒汉方式，建议使用饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用内部类方式。如果涉及到反序列化创建对象时，枚举方式。如果有其他特殊的需求，可以考虑使用双检锁方式。

莫轩然