设计模式之单例模式：饿汉式、懒汉式

单例模式笔记-饿汉式-懒汉式

单例模式定义

一个类有且仅有一个实例，并且自行实例化向整个系统提供。

---

1、饿汉式：

是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

1. 私有化类的构造器
2. 在内部创建一个私有化对象
3. 创建一个公共方法去获取对象，因为要在main中调用此方法，需要声明为静态方法。

优点：饿汉式是线程安全的
缺点：对象加载的时间过长

public class singleton1 {
  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 在内部创建一个对象
   private static Bank instance = new Bank();
   //3 设置一个获得对象的方法
   public static Bank getInstance(){
     return instance;
   }
   
}

---

2、懒汉式：

是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。

1. 私有化类的构造器
2. 先私有化声明当前类的对象，但是不new对象，直接置空
3. 创建一个公共方法去获取对象，因为要在main中调用此方法，需要声明为静态方法

优点：延迟对象的创建

缺点：不加同步的懒汉式是线程不安全的

public class Singleton2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);
    }
}

//懒汉式
class Order{
    //1.私有化类的构造器
    private Order(){}
    //2.先声明当前类的对象 但是不new对象。
    private static Order instance = null;
    //3.声明public、static的返回当前类的对象的方法
    public static Order getInstance(){
    	//先检查实例是否存在，如果不存在，才进入下面的同步块，否则直接return实例
        if(instance == null){
        
            synchronized(Bank.class){
            
            这个同步可以保证，即使多个线程同时判断出instance 是 null
            但同一时间只有一个线程可以进入下面new对象的环节
            
            关键在于 同步里面还要放一个if判断 再判断一次
            为什么呢
            因为 当线程A和线程B同时进入第一个if后，都认为instance是null
            那么他们都想挤进去，然后其中一个比如是A，进入了锁中，另一个就在等待
            A进锁后就可以new出一个对象来
            那么当A释放锁后，B此时还认为instance是null 从而进入new对象环节
            导致new了两个对象
            
            所以，在同步里继续加一个if判断
            这样就可以有效解决线程安全问题
          
               if(instance == null){
               instance = new Order();
               }
             
            }
          
        }
        return instance;
    }
}