单例设计模式：

1：所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例。

2：常见的设计模式有懒汉式和饿汉式。

3：饿汉式：
	坏处：对象加载时间过长。
	好处:饿汉式是线程安全的。
4：懒汉式：
	好处：延迟对象的创建。
	坏处：会存在线程不安全的情况。
5：饿汉式是创建类的同时就已经创建好了一个静态的对象供系统使用，以后不再改变。
6：懒汉式是真正用到的时候才建单例对象，做到了延时加载。也因为如此，才会线程不安全。

饿汉式：
public class SingletonTest1 {
   public static void main(String[] args) {
//    Bank bank1 = new Bank();	 构造器是私有化的，无法new出对象。
//    Bank bank2 = new Bank();	 构造器是私有化的，无法new出对象。
      
      Bank bank1 = Bank.getInstance();
      Bank bank2 = Bank.getInstance();
      
      System.out.println(bank1 == bank2);
   }
}

class Bank{
   
   //1.私有化类的构造器
   private Bank(){
      
   }
   
   //2.内部创建类的对象
   //4.要求此对象也必须声明为静态的
   private static Bank instance = new Bank();
   
   //3.提供公共的静态的方法，返回类的对象
   public static Bank getInstance(){
      return instance;
   }
}

懒汉式之线程不安全写法：
public class SingletonTest2 {
   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.声明当前类对象，没有初始化
   //4.此对象也必须声明为static的
   private static Order instance = null;
   
   //3.声明public、static的返回当前类对象的方法
   public static Order getInstance(){
      
      if(instance == null){
         
         instance = new Order();
         
      }
      return instance;
   }   
}

利用同步机制实现线程安全的懒汉式：
public class BankTest {

}

class Bank{
// 私有化类的构造器
private Bank(){

}
private static Bank instance = null;
public static Bank getInstance(){
//	方式一：效率稍差

//       synchronized (Bank.class) {
//           if(instance == null){
//
//               instance = new Bank();
//           }
//           return instance;
//       }
//	方式二：效率更高
        if(instance == null){

        synchronized (Bank.class) {
            if(instance == null){

                instance = new Bank();
            }

        }
    }
    return instance;
}
}

---

2021-03-27