设计模式note1：单例模式

 * 单例模式：饿汉加载式
 * 1.静态常量饿汉式:类一加载就创建单例实例，浪费内存，效率不高。
 * 2.静态代码块饿汉式：把创建对象方到静态块里
 */
public class HungryMan {

    //1.提供一个私有的构造方法，不让外部访问
    private HungryMan(){}

    //2.创建一个HungryMan的实例，在类加载的时候返回一个唯一的实例对象。
    private final static HungryMan instance = new HungryMan();

/*    //静态代码块加载
    private static HungryMan instance ;
    static {
        instance = new HungryMan();
    }*/

    //3.提供一个方法返回现有的实例对象
    public HungryMan getInstance(){
        return instance;
    }

}

 * 单例模式：懒汉模式
 * 线程安全懒汉式:
 * 1.同步代码块式
 * 2.双重校验式
 * 3.静态内部类式
 * 4.枚举方式
 */

//普通：线程不安全式
public class LazyMan {

    //1.私有化构造函数
    private LazyMan(){}

    //2.创建对象
    private static  LazyMan instance = null;

    //3.提供共有的获取单例的方法
    public static synchronized LazyMan getInstance(){
        if (instance == null){
            instance = new LazyMan();
        }
        return instance;
    }

}

//双重校验式
class LazyMan_DoubleCheck{

    //1.私有化构造函数
    private LazyMan_DoubleCheck(){}

    //2.创建对象
    //双重教研式：volatile是重点，能直接把对象的变化同步到内存中
    private static volatile LazyMan_DoubleCheck instance = null;

    //3.双重校验式：提供公有的获取单例的方法
    // 好处是：不在方法级别加锁，而在内部进行加锁验证。
    //为什么要多加一个if?因为利用volatile进行了及时更新，保证了多线程时不同线程同时获得null实例并创建的清空。
    public static LazyMan_DoubleCheck getInstance(){
        if (instance == null){
            synchronized (LazyMan.class){
                if (instance == null){
                    instance = new LazyMan_DoubleCheck();
                }
            }
        }
        return instance;
    }

}

//静态内部类式
class LazyMan_StaticInnerClass{
    //内部类只在外部类需要使用它的时候才进行一次初始化操作，且无法被外部访问，因此可以作为单例模式的实现

    //1.私有构造函数
    private LazyMan_StaticInnerClass(){}

    //2.通过内部类实例化单例对象
    private static class LazyMan_Instance{
        private static final LazyMan_StaticInnerClass INSTANCE = new LazyMan_StaticInnerClass();
    }

    //3.提供公有获得实例的方法
    public LazyMan_StaticInnerClass getInstance(){
        return LazyMan_Instance.INSTANCE;
    }
}

//4.枚举enum方式
enum LazyMan_Enum{
    INSTANCE;
}
class MyTest{
    public static void main(String[] args) {
        LazyMan instance = LazyMan.getInstance();
        LazyMan instance2 = LazyMan.getInstance();
        if (instance == instance2){
            System.out.println("是单例模式，同一个内存地址！"+instance.hashCode()+":"+instance2.hashCode());
        }
    }
}