单例设计模式

什么叫做单例：

GOF（四人帮）设计模式的一种，它约定了一个类只能存在一个实例对象。

特点：因为只拥有一个实例，极大节省了系统开销。

延时加载：要使用的时候再创造实例（避免对象造出来没有使用而浪费空间）

/**
 * 饿汉式加载
 */
public class SingleLetton1 {
    //类加载时候就进行初始化，线程天然安全，不能延时加载
    private static final SingleLetton1 instance = new SingleLetton1();
    
    private SingleLetton1(){}
    
    //没有同步，所以效率高
    public static SingleLetton1 getInstance(){
        return instance;
    }
}

/**
 * 懒汉式加载
 */
public class SingleLetton2 {
    private static SingleLetton2 instance;
    
    private SingleLetton2(){}
    
    //每次都要同步，势必影响效率
    public synchronized static SingleLetton2 getInstance(){
        if(instance == null){
            instance = new SingleLetton2();
        }
        return instance;
    }
}

/**
 * 双重锁式加载（对懒汉式加载的升级版）
 */
public class SingleLetton3 {
    /**类加载时候不进行初始化，线程天然安全，不能延时加载
     *使用volatile关键字防止多线程访问出现问题，详情移步：
     *http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
     */
    private static volatile SingleLetton3 instance;
    
    private SingleLetton3(){}
    
    //先判断再同步（这样只同步一次，大大提升效率）
    public static SingleLetton3 getInstance(){
        if(instance == null){
            synchronized (SingleLetton3.class) {
                if(instance == null){
                    instance = new SingleLetton3();
                }
            }
        }
        return instance;
    }
} 

/**
 * 内部类式加载（推荐使用）
 *
 */
public class SingleLetton4 {
    /**
     * ClassLoader（类加载器）只会在用到的时候进行加载
     *（不用就不加载），所以具有延时加载的特性，同时线程天然安全
     */
    private static class Instance{
        private static final SingleLetton4 instance = new SingleLetton4();
    }
    
    private SingleLetton4(){}
    
    //不需要同步，效率高
    public static SingleLetton4 getInstance(){
        return Instance.instance;
    }
}

/**
 * 枚举式加载（如果不需要延时加载，推荐使用）
 */
public enum SingleLetton5 {
    //线程天然安全，不能延时加载，而且还能防止通过反序列化和反射构造新的对象
    INSTANCE;
    
    public void operate(){
        ...
    }
}