Java设计模式之单例模式

定义：单例，单个实例，也就是说一个类只能获取一个实例。

类别：饿汉模式、懒汉模式（不考虑线程安全问题）

实现方式：通常在获取类的实例时，是用new来获取，new一次，获取一次实例，如何保证只能获取一次实例呢？

1.首先要保证外部不能使用new xxx()的方式来获取实例，给xxx类的构造方法私有化。

2.构造方法一旦私有化，外部就不可访问，需提供一个公共的方法来获取该类的实例，而且这个方法不能是实例调用的方法（不能够通过创建该类的实例调用此方法），应该是一个类方法。

3.要保证获取的实例是唯一的，需要在类一经加载的时候就创建实例，类只会加载一次，实例也就只会创建一次。

饿汉模式实现方式：

/**
 * @ClassName: SingletonHunger
 * @Description: (饿汉模式)
 * @author: 阿Q
 * @date 2019年9月5日
 *
 */
public class SingletonHunger {
	
	//3.如何保证实例唯一？类一加载的时候，就创建对象，而且只会创建一次对象，这样就能保证实例唯一
	private static SingletonHunger instance=new SingletonHunger();
	
	//1.首先保证不能使用new XXX()来创建实例,把构造函数设置为外部不可访问
	private SingletonHunger(){ 
	}
	//2.外部不可访问，怎么创建实例呢？需提供一个对外方法，通过该方法获取实例；而且这个方法不能是实例的方法（不能够创建实例来调用方法），只能设置为类方法
	public static SingletonHunger getInstance(){
		return instance;
	}
	
}

懒汉模式实现方式（不考虑线程安全问题）：

/**
 * @ClassName: SingletonLazy
 * @Description: (懒汉模式)
 * @author: 阿Q
 * @date 2019年9月5日
 *
 */
public class SingletonLazy {
	
	private static SingletonLazy instance = null;
	
	private SingletonLazy(){}
	
	public static SingletonLazy getInstance(){
		if(instance==null){
			instance=new SingletonLazy();
		}
		return instance;
	}
}

测试获取的实例是否唯一：

public class Test {
	
	public static void main(String[] args) {		
		SingletonHunger singleton1 = SingletonHunger.getInstance();
		SingletonHunger singleton2 = SingletonHunger.getInstance();
		if(singleton1==singleton2){
			System.out.println("true");
		}else{
			System.out.println("false");
		}
		
		SingletonLazy singleton3 = SingletonLazy.getInstance();
		SingletonLazy singleton4 = SingletonLazy.getInstance();
		if(singleton3==singleton4){
			System.out.println("true");
		}else{
			System.out.println("false");
		}
	}
}

打印结果：

true
true

懒汉模式和饿汉模式的区别：

饿汉模式：类一经加载就会创建实例，浪费内存，线程安全。

懒汉模式：需要使用时才会创建实例，但是线程不安全。关于懒汉模式的线程安全的实现方式，待补充。。

待补充。。。

更深层次的应用可参考博客：

https://blog.csdn.net/justloveyou_/article/details/64127789

https://www.cnblogs.com/awkflf11/p/9906431.html