源代码：https://gitee.com/AgentXiao/SingletonPattern

一、核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

二、优点

单例模式只生成一个实例，减少了系统性能开销

三、各种版本的单例模式

实现单例模式的基本规则：
（1）构造器私有化，不让外部创建对象
（2）提供外部调用的对象的方法

1、饿汉式

饿汉式的特点是“饿”，即类加载时便创建对象。

    //饿汉式：类初始化时立即加载
    private static SingletonDome01 singleton = new SingletonDome01();
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome01(){
    }
    //提供访问方法，每次访问返回的都是同一个对象
    public static SingletonDome01 getSingleton(){
        return singleton;
    }

特点：
线程安全的：虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因。
问题：
可能造成资源浪费：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

2、懒汉式

懒汉式的特点是“懒”，即类加载的时候不创建对象，在第一次调用访问方法时创建，再次调用时直接调用。

    //懒汉式：类初始化时不立即加载
    private static SingletonDome02 singleton;
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome02(){
    }
    //提供访问方法，第一次访问时创建，之后直接返回。但是需要设置同步
    public static synchronized SingletonDome02 getSingleton(){
        if(singleton == null){
            singleton = new SingletonDome02();
        }
        return singleton;
    }

问题：
每次调用getInstance()方法都要同步，并发效率较低。在不加synchronized时，假设A、B同时访问，A创建了对象，但是由于B也是null，也创建了一个对象，导致创建了多个对象，不符合单例的原则。

3、双重检测锁

因为饿汉式会让整个方法进行等待，效率低。因此将同步内容下方到if内部，提高了执行的效率。不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。

    //懒汉式：类初始化时不立即加载
    private static SingletonDome03 singleton;
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome03(){
    }
    //提供访问方法，第一次访问时创建，之后直接返回
    public static SingletonDome03 getSingleton(){
        if (singleton == null) {
            SingletonDome03 sc;//第一次访问时定义一个对象
            synchronized (SingletonDome03.class) {
                sc = singleton;
                if (sc == null) {
                    synchronized (SingletonDome03.class) {
                        if(sc == null) {
                            sc = new SingletonDome03();
                        }
                    }
                    singleton = sc;
                }
            }
        }
        return singleton;
    }

由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。

4、静态内部类实现

    //静态内部类不会立即加载，只有真正调用时才会加载
    private static class SingletonClass{
        private static final SingletonDome04 singleton = new SingletonDome04();
    }
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome04(){
    }
    //提供访问方法，第一次访问时创建，之后直接返回。但是需要设置同步
    public static synchronized SingletonDome04 getSingleton(){
        return SingletonClass.singleton;
    }

说明：
（1）加载外部类时不会直接创建对象；
（2）只有在调用访问方法时才会加载静态内部类去创建对象，同时加载一次类保证了线程安全。singleton是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
（3）兼备了并发高效调用和延迟加载的优势！

5、问题（针对以上四种方式）

（1）反射破解

        SingletonDome02 s1 = SingletonDome02.getSingleton();
        SingletonDome02 s2 = SingletonDome02.getSingleton();
        System.out.println(s1);
        System.out.println(s2);

        System.out.println();

        Class<SingletonDome02> clazz = (Class<SingletonDome02>) Class.forName("pri.xiaowd.singleton.SingletonDome02");
        Constructor<SingletonDome02> c = clazz.getDeclaredConstructor(null);
        c.setAccessible(true);//忽略权限
        SingletonDome02 s3 = c.newInstance();//构造对象
        SingletonDome02 s4 = c.newInstance();//构造对象
        System.out.println(s3);
        System.out.println(s4);

由此可见，利用反射破解了单例模式。

单例破解

通过在私有化的构造方法中抛异常的方法可以解决。如果对象已经创建了，则报错。

    private SingletonDome02(){
        if(singleton != null){
            throw new RuntimeException();
        }
    }

（2）反序列化破解
前提条件是SingletonDome02类实现了Serializable接口。

        //通过反序列化破解单例
        FileOutputStream fos = new FileOutputStream("d:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.close();
        fos.close();

        ObjectInputStream ios = new ObjectInputStream(new FileInputStream("d:/a.txt"));
        SingletonDome02 s3 = (SingletonDome02) ios.readObject();
        System.out.println(s3);

反序列化破解单例

解决办法：在SingletonDome02类中定义一个方法.反序列化时会自动调用。

    //反序列化时如果定义了readResolve则直接返回此对象，不需要再创建
    private Object readResolve(){
        return singleton;
    }

6、枚举实现

    //这个枚举元素本身就是单例
    SINGLETON;
    
    //自己想要的操作
    public static void getSingleton() {
        
    }

优点：
– 实现简单。
– 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞。
缺点：
– 无延迟加载。

System.out.println(SingletonDome05.SINGLETON == SingletonDome05.SINGLETON);

返回true。

7、比较

常见的五种单例模式实现方式
– 主要：
• 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式（线程安全，调用效率高。 但是，可以延时加载)
• 枚举式（线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列化漏洞！)

如何选用?
1、单例对象占用资源 少，不需要延时加载：枚举式 好于 饿汉式
2、单例对象 占用 资源 大，需要延时加载：静态内部类式 好于 懒汉式

四、各种方式的效率（相对）

        long start = System.currentTimeMillis();

        int ThreadNum = 10;
        final CountDownLatch countDownLatch = new CountDownLatch(ThreadNum);

        for(int i=0;i<ThreadNum;i++){
            new Thread(new Runnable(){
                @Override
                public void run() {
                    for(int i=0;i<1000000;i++){
                        //Object o = SingletonDome04.getSingleton();
                        Object o = SingletonDome05.SINGLETON;
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();//main线程阻塞，直到计数器变为0，才会继续往下执行

        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end - start));

饿汉式SingletonDome01 ： 86
懒汉式SingletonDome02 ： 374
双重检测锁SingletonDome03 ： 143
静态内部类SingletonDome03 ： 474
枚举SingletonDome03 ： 24