单例模式的应用场景

单例模式的优点

饿汉懒汉

1.所谓单例模式，就是采取一定个方法保证整个软件系统中，对某个类只能存在一个对象实例。
2.实现：饿汉式，懒汉式
3.区分懒汉式和饿汉式
饿汉式：
    坏处：加载时间过长。
    好处：饿汉式是线程安全的。
懒汉式：
    好处：延迟对象创建。
    坏处：懒汉式是线程不安全的。(使用同步机制可以将懒汉式改为线程安全的)

饿汉模式

饿汉式：不管用不用，先造。

public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1==bank2);//true


    }
}
//饿汉式：不管用不用，先造。
class Bank{
    //1.私有化类的构造器:为了避免外部创建对象
    private Bank(){}
    //2.内部创建类的对象
    //4.要求此对象也是静态的
    private static Bank instance = new Bank();
    //3.提供公共的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

线程安全的懒汉模式

懒汉式：不用不造，用了再造

public class BankTest1 {
}
//线程安全的懒汉式
class Ban{
    private Ban(){}
    private static Ban instance = null;
    public static synchronized Ban getInstance(){
        //方式一：效率低
//        if (instance == null){//第一个线程进入进入之后，创建了对象。那么在之后进入的线程，if判断为false，不创建新的对象。
//            instance = new Ban();
//        }
//        return  instance;
        //方式二：效率更高
        if(instance == null){//可能有多个线程进入，所以下面的判断不能够省略
            synchronized (Ban.class){
                if (instance == null){
                    instance = new Ban();
                }
            }
        }
        return instance;
    }
}

线程不安全的懒汉模式(不使用线程不安全的)

public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);//true
    }
}
//懒汉式：不用不造，用了再造
class Order{
    //1.私有化类的构造器
    private Order(){}
    //2.声明当前类的对象，没有初始化
    //4.此对象必须声明为static
    private static Order instance = null;
    //3.声明public、static返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }

}