单例模式两种实现方式

饿汉式：一开始就实例化对象，在方法中直接返回，线程安全

public class Hungry {
    //私有化构造器，不允许外创建类对象
    private Hungry(){};
    //在类的内部创建对象
    private static final Hungry hungry=new Hungry();

    /**
     * 返回内部创建的类对象
     * @return hungry
     */
    public static Hungry getInstance(){
       return  hungry;
    }
}

@Test
    public void testHungry(){
        Hungry hungryA=Hungry.getInstance();
        Hungry hungryB=Hungry.getInstance();
        System.out.println(hungryA==hungryB);//true说明两个对象指向同一个地址
    }
    结果：true

懒汉式：一开始不实例化，用的时候再实例化，操作的共享数据使用synchronized同步代码块保证线程安全。

public class Lazy {
    //私有化构造器
    private Lazy(){};
    //声明变量不初始化，用的时候在实例化
    private static  Lazy instance;
    public static Lazy getInstance(){
        if(instance==null)
            synchronized(Lazy.class) {
                if (instance == null)
                    instance = new Lazy();//实例化对象
            }
        return instance;
    }
}

 @Test
    public void testLazy(){
        Lazy lazy1=Lazy.getInstance();
        Lazy lazy2=Lazy.getInstance();
        System.out.println(lazy1==lazy2);//true
    }