单例模式的记录

lazy loading(懒加载)：意思就是不在类加载的时候不初始化，而是在调用方法的时候初始化。

1、懒汉式（线程不安全）

    public class Singleton {
        private static Singleton instance;
        private Singleton (){}
     
        public static Singleton getInstance() {
            if(instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

优点：lazy loading

缺点：多线程下不能工作。


2、懒汉式（线程安全）

    public class Singleton {
        private static Singleton instance;
        private Singleton (){}
     
        public static synchronized Singleton getInstance() {
            if(instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

这种仅仅在在第一种的基础上给getInstance( )加了一把锁。

优点：lazy loading，线程安全

缺点：效率低下


3、双重校验的方式

    public class Singleton {
        private static volatile Singleton instance;
        private Singleton (){}
     
        public static Singleton getInstance() {
            if(instance == null) {
                synchronized (Singleton.class) {
                    if(instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

优点：线程安全，效率上相对2来说高一点，lazy loading

缺点：效率上还是不高


4、饿汉式

    public class Singleton {
        private static Singleton instance = new Singleton();
        private Singleton (){}
     
        public static Singleton getInstance() {
            return instance;
        }
    }

优点：让instance在类加载的时候初始化，由于静态变量只会在类加载的时候初始化一次，从而避免多线程初始化的情况。

缺点：在类加载的时候就会实例话，所以不是lazy loading，

5、静态内部类

    public class Singleton {
        private static class SingletonHolder{
            private static final Singleton INSTANCE = new Singleton();
        }
        private Singleton (){}
     
        public static Singleton getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }

优点：由于静态内部类跟外部类是平级的，所以外部类加载的时候不会影响内部类，因此实现了lazy loading；同时也是利用静态变量的方式，使得INSTANCE只会在SingletonHolder加载的时候初始化一次，从而保证不会有多线程初始化的情况，因此也是线程安全的。

这个也是最合理最常规的实现单例模式的方式，推荐。

6、枚举

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

这种是实现单例模式不太常规但是很合理的方式。