单例模式（一）

1，私有化构造器，私有一个实例对象，通过静态方法，让外部调用私有化的实例对象
/**
 * 懒汉式
 * 单例的标准模式，使用判断来进行延迟加载，
 * 使用synchronized关键字来避免多线程问题，但影响性能
 */
class Singleton{

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

/**
 * 饿汉式
 * 在声明对象的时候就开始初始化对象，但初始化比较负责，会导致程序缓慢
 */
class Singleton1 {

    private static Singleton1 instance = new Singleton1();
    private Singleton1(){};
    public static Singleton1 GetInstance(){
        return instance;
    }
}

/**
 *双重加锁机制，懒汉式的加强版
 * 讲synchronized放到实例化方法内，并使用volatile关键字修饰对象，既避免了多线程问题，
 * 又不会影响性能，但volatile本身有问题，少用
 */
class Singleton2{

    private static volatile Singleton2 instance = null;
    private Singleton2(){}

    public static Singleton2 GetInstance(){
        if(instance == null){
            synchronized (Singleton2.class){
                if(instance == null)
                    return new Singleton2();
            }
        }
        return instance;
    }
}

/**
 * Lazy initialization holder class
 * 这里创建了一个静态类，使用内部类的机制使单例对象延迟加载，内部类相当是外部类的静态部分，
 * 所以通过jvm来保证线程安全
 */
class Singleton3{
    private static class SingletonHolder{
            private static Singleton3 instance = new Singleton3();
    }
    private Singleton3(){}
    public static Singleton3 getInstance(){
        return SingletonHolder.instance;
    }
}

/**
 * 单因素的枚举类，已经实现了单例
 */
enum Singleton4{
    sinleton;
}