设计模式之单例模式

**单例模式：

就是只有一个实例**，并且它自己负责创建自己的对象，这个类提供了一种访问其唯一对象的方式，可以是直接访问，不需要实例化该类的对象。一个类只能构建一个对象的模式。
核心代码就是：构造方法私有化**

1 懒汉模式

用的时候才去检查有没有实例，如果有则返回，没有则新建

public class Singleton {
    private Singleton(){} //私有构造函数
     private static Singleton instance = null; //单例对象
    public static Singleton getInstance(){
        if (instance == null)       
                instance = new Singleton();            
        }
        return instance;
    }
}

1.要想让一个类只能构建一个对象，自然不能让它随便去做new操作，因此Signleton的构造方法是私有的
2 getInstance是获取单例对象的方法

2 饿汉模式

实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。好处是没有线程安全的问题，坏处是浪费内存空间。

public class Singleton {
    private Singleton(){}
     private  static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

双重检测

 private Singleton(){}
    private volatile static Singleton instance = null;
    public static Singleton getInstance(){
        if (instance == null){  //双重检测机制
            synchronized (Singleton.class){//同步锁
                if (instance == null){  //双重检测机制
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

使用volatile保证禁止重排序

用静态内部类实现单例模式：

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

外部无法访问静态内部类LazyHolder，只有当调用Singleton.getInstance方法的时候，才能得到单例对象INSTANCE。
INSTANCE对象初始化的时机并不是在单例类Singleton被加载的时候，而是在调用getInstance方法，使得静态内部类LazyHolder被加载的时候。因此这种实现方式是利用classloader的加载机制来实现懒加载，并保证构建单例的线程安全。