单例模式

设计模式–单例模式

模式定义：保证一个类只有一个实例，并且提供一个全局访问点
场景：重量级的对象，不需要多个实例，如：线程池、数据库连接池

1、懒汉模式：

延迟加载，只有在真正使用的时候，才开始实例化
   1）线程安全问题
   2）double check 加锁优化
   3）编译器(JIT),CPU有可能对指令进行重排序，导致使用到尚未初始化的实例，可以通过添加volatile关键字进行修饰，
       对于volatile修饰的字段，可以防止指令重排

/**
 * 懒汉模式：延迟加载，只有在真正使用的时候，才开始实例化
 */
public class LazySingletonTest {
    public static void main(String[] args){
        /***********************第一种：简单单线程****************************/
//        LazySingleton instance1 = LazySingleton.getInstance();
//        LazySingleton instance2 = LazySingleton.getInstance();
//        System.out.println(instance1 == instance2); // 返回结果为true
        /***********************第一种：简单多线程****************************/
        // 多线程下，如果同时走到判断if(instance == null)，则会创建多个实例，破坏了单例的定义
        new Thread(()->{
            LazySingleton instance3 = LazySingleton.getInstance();
            System.out.println(instance3);
        }).start();

        new Thread(()->{
            LazySingleton instance4 = LazySingleton.getInstance();
            System.out.println(instance4);
        }).start();
    }
}


class LazySingleton{
    private volatile static LazySingleton instance; // 防止对应堆空间发生重排序，多线程情况下，防止重排序volatile
    private LazySingleton(){

    }

    // 1、每次都会对此方法进行加锁，则会造成性能的损耗。不管实例有没有被初始化都会进行加锁，没有必要的
    // 2、实例不为空的情况下是不用加锁的，只有在为空的时候进行加锁
    public static LazySingleton getInstance(){
        if(instance == null){
            /*try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            // 如果多个线程并发其实还是有一点性能损耗，但总比在方法加锁好
            synchronized (LazySingleton.class){
                // 还是会存在两个线程实例化两次，所以再进行check一次
                if(instance == null){
                    instance = new LazySingleton();
                    // 字节码层 第1步发生在2、3之前，2、3可以颠倒，对于单线程没有关系
                    // JIT、CPU
                    // 1、分配空间
                    // 2、初始化
                    // 3、引用赋值（操作堆空间值的应用）
                }
            }

        }
        return instance;
    }
}

2、饿汉模式：

   类加载的初始化阶段就完成了实例的初始化。本质上就是借助于jvm类加载机制，保证实例的唯一性
   类加载过程：
   1、加载二进制数据导内存中，生成对应的Class数据结构
   2、连接：a.验证，b.准备(给类的静态成员变量赋默认值) ，c.解析
   3、初始化：给类的静态变量赋初值
   只有在真正使用对应的类时，才会触发初始化，如（当前类时启动类即main函数所在类，直接进行new操作，访问静态属性，访问静态方法，用反射
   访问类，初始化一个类的子类等）

public class HungrySingletonTest {
    public static void main(String[] args){
        HungrySingleton instance1 = HungrySingleton.getInstance();
        HungrySingleton instance2 = HungrySingleton.getInstance();
        System.out.println(instance1 == instance2); // 返回结果为true
    }
}

// 饿汉模式
class HungrySingleton {
    private static HungrySingleton instance = new HungrySingleton();

    // 私有化构造函数，避免在外部调用new single进行实例化
    private HungrySingleton() {

    }
    public static HungrySingleton getInstance(){
        return instance;
    }
}

3、静态内部类

1）本质上是利用类的加载机制来保证线程安全
2）只有在实际使用的时候，才会触发类的初始化，所以也是懒加载的一种形式（懒汉模式）
3）饿汉模式、静态内部类、枚举可以做到防御反射攻击
4）可序列化

public class InnerClassSingletonTest {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException {
        /*InnerClassSingleton instance1 = InnerClassSingleton.getInstance();
        InnerClassSingleton instance2 = InnerClassSingleton.getInstance();
        System.out.println(instance1 == instance2); // 返回结果为true*/

        // 多线程
        /*new Thread(()->{
            InnerClassSingleton instance3 = InnerClassSingleton.getInstance();
            System.out.println(instance3);
        }).start();
        new Thread(()->{
            InnerClassSingleton instance4 = InnerClassSingleton.getInstance();
            System.out.println(instance4);
        }).start();*/

        // 反射攻击实例化
        // 获取构造函数
        /*Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true); // 可以拿到私有变量,私有方法访问权
        // 实例化
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();

        // 拿实例
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        System.out.println(innerClassSingleton == instance); // 返回结果为false*/



        // instance实例序列化到磁盘上
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        /*ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testSerializable"));
        oos.writeObject(instance);
        oos.close();*/
        // 反序列化，读取序列化文件
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testSerializable"));
        InnerClassSingleton object = (InnerClassSingleton)ois.readObject();
        System.out.println(instance == object);
    }
}

class InnerClassSingleton implements Serializable {
    static final long serialVersionUID = 42L;  // 版本号保证单例
    // 定义私有静态内部类,本质上也是基于jvm类加载机制，保证线程安全
    // 懒加载的方式（懒汉模式）
    private static class InnerClassHolder{
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
    private InnerClassSingleton(){
        // 防止反射攻击
        if(InnerClassHolder.instance!=null){
            throw new RuntimeException("单例不允许多个实例");
        }

    }
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.instance;
    }

    Object readResolve() throws ObjectStreamException{
        return InnerClassHolder.instance;
    }

    String temp = "ss";
}

4、枚举类

public enum EnumSingleton {
    INSTANCE;

    public void print(){
        System.out.println(this.hashCode());
    }
}

/**
 * 基于jvm类加载，也是线程安全的，预防反射攻击
 */
class EnumTest{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        /*EnumSingleton instance1 = EnumSingleton.INSTANCE;
        EnumSingleton instance2 = EnumSingleton.INSTANCE;
        System.out.println(instance1 == instance2); // 返回结果为true*/

        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
		// 获取实例异常
        EnumSingleton instance = declaredConstructor.newInstance("INSTANCE",0);
        
    }
}

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at EnumSingleton.EnumTest.main(EnumSingleton.java:33)