小记_单例设计模式

单例模式的要点：

• 某个类只能有一个实例
  要想实现只能有一个实例，就不能随意的去创建对象，所以构造方法就必须私有化；
• 该类的实例对象只能自己创建
  该类的实例对象只能自己创建，那么就需要含有一个该类的静态变量来保存这个唯一的实例；
• 必须自行向整个系统提供这个实例
  对外提供获取该实例对象的方式：（1）直接暴露；（2）用静态变量的get方法获取；

单例模式的实现方式

饿汉式

饿汉式，顾名思义，想象一个人非常饿的时候，是很着急的，所以没有那么多的形式，直接就创建对象。
由于类加载的方式，就决定了饿汉式，不会存在线程安全问题；

直接实例化饿汉式

简单直接：
构造方法私有化；
公有静态变量保存唯一实例，因为是唯一实例，所以可用final修饰，因为用final修饰，可以将变量名全部大写；

public class Singleton {
    public static final Singleton INSTANCE = new Singleton();
    private Singleton(){}
}

使用枚举式实现饿汉式

枚举，就是一个类拥有有限个实例，可以将它写为只有一个实例的枚举，就实现了单例模式；
与直接实例化不同的是，枚举的方式帮我们重写了toString()方法，所以直接输出对象和直接实例化不同；

public enum Singleton {
    INSTANCE;
}

静态代码块实现饿汉式

适用于比较复杂的实例化；

public class Singleton {
    public static final Singleton INSTANCE;
    static {
        INSTANCE = new Singleton();
    }
    private Singleton(){}
}

懒汉式

懒汉式，顾名思义，就是这个人非常懒，不到最后关头，永远不去做这个事情，所以直到要用这个对象的时候才去创建。

线程不安全（适用于单线程）

使用下面这种方式创建的单例，在单线程模式下是没有问题的，但是在多线程情况下，就会存在线程安全的问题了；

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

线程安全（适用于多线程）

使用synchronized关键字对类加锁：

public class Singleton {
    private static Singleton INSTANCE;
    private Singleton(){}
    public static Singleton getInstance(){
        synchronized (Singleton.class){
            if(INSTANCE == null){
                try{
                    Thread.sleep(100);
                }catch (Exception e){
                    e.printStackTrace();
                }
                INSTANCE = new Singleton();
            }
        }
        return INSTANCE;
    }
}

为了提高效率，可以做一下改善，在外面再加一层判断，因为当里面的线程进入休眠状态，但是已经创建了对象实例时，就直接返回实例就好了，不需要在等待；

public class Singleton {
    private static Singleton INSTANCE;
    private Singleton(){}
    public static Singleton getInstance(){
        if(INSTANCE == null) {
            synchronized (Singleton.class){
                if(INSTANCE == null){
                    try{
                        Thread.sleep(100);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

使用静态内部类（适用于多线程）

静态内部类不会随着外部类的加载和初始化而初始化，他是要单独去加载和初始化的，利用这一点，可以在内部类加载和初始化时，在创建实例；
使用这种方式比上面的要简洁多了

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