单例模式笔记

一. 饿汉式(静态常量)

1. 构造器私有化(防止外界new)
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法getInstance()

class Singleton{
    private static Singleton instance = new Singleton();  //接收唯一实例
    private Singleton(){};   //显示地私有构造方法，使得外界无法new此类的实例
    public static Singleton getInstance(){
        return instance;
    }
}

优点：写法简单；在类加载的时候就完成了类的实例化，避免了线程同步问题。
注：利用了ClassLoader的线程安全机制。ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字
缺点：在类加载的时候就完成类的实例化，没有达到Lazy Loading的效果。如果从始至终都没有用到这个实例，则会造成资源的浪费

二. 饿汉式(静态代码块)

class Singleton{
    private static Singleton instance;  //接收唯一实例
    private Singleton(){};   //显示地私有构造方法，使得外界无法new此类的实例
    static {   //静态代码块中创建单例对象
        instance = new Singleton();
    }
    public static Singleton getInstance(){
        return instance;
    }
}

注：静态变量赋值和静态代码块其实都是在类初始化阶段执行，无本质区别。优缺点和第一种一样。

三. 懒汉式(线程不安全)

class Singleton{
    private static Singleton instance;  //接收唯一实例
    private Singleton(){};   //显示地私有构造方法，使得外界无法new此类的实例
    public static Singleton getInstance(){  
        //当使用到getInstance时才尝试去创建对象，而不是在类加载的时候就创建出来
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

优点：起到了Lazy Loading的效果，但是只能在单线程下使用
缺点：在多线程下，一个线程进入if(instance == null)判断语句块之后，还未来得及向下执行，即还未来得及创建一个实例对象，又有线程通过了这个判断，此时会创建多个实例
结论：真实开发中不要用这种方式

四. 懒汉式(线程安全，同步方法)

class Singleton{
    private static Singleton instance;  
    private Singleton(){};   
    //synchronized同步方法，解决线程同步问题
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

优点：解决了线程不安全问题
缺点：效率低，每个线程要获得实例对象的时候都要进行同步，但是其实只要在执行实例化代码的时候进行同步就够了
结论：实际开发中不推荐此种方式

五. 懒汉式(同步代码块)

class Singleton{
    private static Singleton instance;
    private Singleton(){};
    public static Singleton getInstance(){
        if(instance == null){
        //这种方式是为了解决线程同步的同时不总是进行加锁，但是这种错误方式却会导致线程不同步
            synchronized (Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

这种方式不能在真实开发中使用。因为一个线程进行if(instance == null)判断，获取Singleton.class类锁后还未创建对象，其他线程同时进行if(instance == null)，导致创建多个实例。

六. 懒汉式(线程安全，双重检查)

class Singleton{
    private static volatile Singleton instance;  //volatile：每个线程的变量及时同步到主存
    private Singleton(){};
    public static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Double-Check概念在多线程开发中经常被用到。
优点：线程安全；延迟加载；效率较高
推荐此种方式！！！

七、静态内部类

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

1. 外部类被装载的时候，静态内部类不会被装载(懒加载)
2. 当调用getInstance时会导致静态内部类的装载，只装载一次(类的静态属性只会在第一次装载类的时候初始化一次)，且线程安全(类装载机制通过synchronized关键字保证只加载一个类)

推荐使用此种方式！！！

八、枚举