四种单例模式优缺点，以及防止序列化反序列化破解

1恶汉式单例模式

package com.example.demo.singleton;

/**
 * 恶汉式 单例模式
 * 优点：类初始化即加载对象，1、线程安全（加载类时，天然的是线程安全的）；2、效率高（不需同步）
 * 缺点：未延迟加载
 */
public class SingletonDemo {
    private static SingletonDemo instance = new SingletonDemo();
    private SingletonDemo(){}
    public static SingletonDemo getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        SingletonDemo demo1 = SingletonDemo.getInstance();
        SingletonDemo demo2 = SingletonDemo.getInstance();
        System.out.println(demo1);
        System.out.println(demo2);
    }
}

2、恶汉式单例模式

package com.example.demo.singleton;

/**
 * 懒汉式 单例模式
 * 优点：延迟加载
 * 缺点：方法需同步，效率低
 */
public class SingletonDemo1 {
    private static SingletonDemo1 instance ;
    private SingletonDemo1(){}
    public static synchronized SingletonDemo1 getInstance(){
        if(instance == null){
            instance = new SingletonDemo1();
        }
        return instance;
    }

    public static void main(String[] args) {
        SingletonDemo1 demo1 = SingletonDemo1.getInstance();
        SingletonDemo1 demo2 = SingletonDemo1.getInstance();
        System.out.println(demo1);
        System.out.println(demo2);
    }
}

3、静态内部类 单例模式

package com.example.demo.singleton;

/**
 * 静态内部类 单例模式
 * 优点：1、类加载及生成对象，线程安全；2、方法不需同步，效率高；3、延迟加载
 */
public class SingletonDemo2 {
    private static class SingleInstance{
        private static final SingletonDemo2 instance = new SingletonDemo2();
    }
    private SingletonDemo2(){}

    public static SingletonDemo2 getInstance(){
        return SingleInstance.instance;
    }

    public static void main(String[] args) {
        SingletonDemo2 demo1 = SingletonDemo2.getInstance();
        SingletonDemo2 demo2 = SingletonDemo2.getInstance();
        System.out.println(demo1);
        System.out.println(demo2);
    }
}

4、枚举 单例模式

package com.example.demo.singleton;

/**
 * 枚举 单例模式
 * 优点：效率高，线程安全
 * 缺点：未实现延迟加载
 */
public enum SingletonDemo3 {
    //这个枚举元素，本身就是单例对象！
    INSTANCE;

    //添加自己需要的操作！
    public void singletonOperation(){
    }
}

5、如何防止序列化和反序列化漏洞 (用懒汉式 单例模式举例)

package com.example.demo.singleton;

import java.io.*;

/**
 * 懒汉式 单例模式  (如何防止反射和反序列化漏洞)
 */
public class SingletonDemo4 implements Serializable {
    private static SingletonDemo4 instance ;
    private SingletonDemo4(){
        //防止序列化初始化出多个对象
        if(instance != null){
            throw new RuntimeException();
        }
    }
    public static synchronized SingletonDemo4 getInstance(){
        if(instance == null){
            instance = new SingletonDemo4();
        }
        return instance;
    }

    //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
    private Object readResolve(){
        return instance;
    }

    public static void main(String[] args) throws Exception {
        SingletonDemo4 demo1 = SingletonDemo4.getInstance();
        SingletonDemo4 demo2 = SingletonDemo4.getInstance();
        System.out.println(demo1);
        System.out.println(demo2);

        //通过反射序列化对象
        /*Class clazz = (Class) Class.forName("com.example.demo.singleton.SingletonDemo4");
        Constructor constructor = clazz.getDeclaredConstructor(null);
        //跳过权限 访问私有的方法，
        constructor.setAccessible(true);

        SingletonDemo4 demo3 = constructor.newInstance();
        SingletonDemo4 demo4 = constructor.newInstance();

        System.out.println(demo3 == demo4); //false
        //增加防止代码后 抛出java.lang.RuntimeException 异常；
        System.out.println(demo3 == demo4); //false*/

        //反序列化
        //通过反序列化的方式构造多个对象
        FileOutputStream fos = new FileOutputStream("F:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(demo1);
        oos.close();
        fos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:/a.txt"));
        SingletonDemo4 demo5 =  (SingletonDemo4) ois.readObject();
        //为增加防止代码readResolve()前返回false
        //增加readResolve()后返回true
        System.out.println(demo1 == demo5);

    }
}