单例模式 ( 饿汉式 与 懒汉式 以及 懒汉式的线程安全示例 )

1.单例模式：一个类只能创建一个实例化对象。为了保证只能有一个实例，我们需要将构造器进行私有化（private），构造器私有之后外部能不能调用构造器去创建对象，只能提供一个static修饰的方法用于返回该类的唯一实例。

  1.1饿汉式：线程安全 

   代码结构：

class Bank{
    public static void main(String[] args) {
		Bank b = Bank.getInstance();
		Bank b1 = Bank.getInstance();
		System.out.println(b == b1); //true
    }   
	// 1,私有化构造器
	private Bank() {
	}
	// 2,内部需要提供一个当前类的实例
	private static Bank bank  = new Bank();
	// 3,提供一个公共静态方法，返回当前类的对象
	public static Bank getInstance() {
		return bank;
	}
}

  

1.2懒汉式:在多线程下不安全，有可能出现多个对象。

代码结构：

class Singleton{
        public static void main(String[] args) {	
		Singleton o =Singleton.getInstance();
		Singleton o1 = Singleton.getInstance();
		System.out.println(o==o1); //true
	}
	// 1,构造器私有化
	private Singleton() {}
	// 2,在类的内部提供上一个当前类的实例
	private static Singleton singleton =null;
	// 3,提供一个公共静态方法。返回当前类的对象
	public static Singleton getInstance() {
		if(singleton == null) {
			singleton =  new Singleton();
		}
		return singleton;
	}
}

懒汉式线程不安全的原因 ：是在高并发环境下可能同时有2个或以上的线程访问getInstance()类方法，又因为new操作不具有原子性，所以会导致产生2个实例的问题。

为了解决懒汉式线程安全问题，可以采用双重检测机制

也可以去看这篇博客 更详细：https://blog.csdn.net/weixin_42617262/article/details/90448083  

代码如下

class Singleton{
  
    private static volatile Singleton singleton;//第二层锁，volatile关键字禁止指令重排
    
    public static Singleton getInstance(){
        if(singleton==null){//第一层检查，检查是否有引用指向对象，高并发情况下会有多个线程同时进入
            synchronized (Singleton.class){//第一层锁，保证只有一个线程进入
                
                if(singleton==null){//第二层检查
                    
                    singleton=new Singleton();
                    
                }
            }
        }
        return singleton;
    }
}