设计模式——单例模式

核心作用： 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
主要：
      饿汉式（线程安全，调用效率高，但是不能延迟加载）
      懒汉式（线程安全，调用效率不高，但是可以延迟加载）
其它：
      双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）

      静态内部类式（线程安全，调用效率不高，也可以延迟加载）

      枚举单例（线程安全，调用效率高，不能延迟加载）

选用：

      单例对象占用资源小，不需要延迟加载：建议用枚举式

      单例对象占用资源大，需要延迟加载，建议用静态内部类式

饿汉式：

public class SingleDemo1 {

    private static SingleDemo1 instance = new SingleDemo1();   // 类初始化时，立即加载该对象

    private SingleDemo1(){}

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

懒汉式：

public class SingleDemo2 {

    private static SingleDemo2 instance;

    private SingleDemo2(){}

    // 方法上做同步，所以效率比较低
    public synchronized static SingleDemo2 getInstance() {
        if(instance == null) {
            instance = new SingleDemo2();
        }
        return instance;
    }
}

双重检测锁式：

public class SingleDemo3 {

    private static SingleDemo3 instance;

    private SingleDemo3(){}

    /*
        方法内部有双重检测锁，保证了线程安全，
        但是由于JVM底层内部模型原因，偶尔会出问题
      */
    public static SingleDemo3 getInstance() {

        if(instance == null) {
            synchronized (SingleDemo3.class) {
                SingleDemo3 singleDemo;
                synchronized (SingleDemo3.class) {
                    singleDemo = instance;
                    if(singleDemo == null) {
                        singleDemo = new SingleDemo3();
                    }
                    instance = singleDemo;
                }
            }
        }
        return instance;
    }
}

静态内部类式：

public class SingleDemo4 {

    private static class SingleClassInstance {
        private final static SingleDemo4 instance = new SingleDemo4();
    }

    private SingleDemo4() {}

    // 只有在调用方法的时候才会加载SingleClassInstance，所以是懒加载的
    public static SingleDemo4 getInstance() {
        return SingleClassInstance.instance;
    }
}

枚举式：

public enum SingleDemo5 {

    INSTANCE;

    // 可添加自定义操作
    public void singletonOperation() {
        System.out.println("SingleDemo5");
    }
}