java设计模式-单例

单例模式意义在于全局唯一

单例模式众所周知分为 饿汉式、懒汉式；

饿汉式单例展示:(因为类一加载即初始化，没有并发问题。缺点就是 ，如果类初始化过大，甚至后期没有使用，有资源浪费)

public class HungrySingleton{

	private static final HungrySingleton instance = new HungrySingleton();
	
	private HungrySingleton(){};
	
	public static HungrySingleton getInstance(){
		reutrn instance;
	}

}

懒汉式单例展示:（使用的时候在加载 ，使用了synchronized 解决并发问题， 缺点是synchronized 浪费性能 ）

public class LazySingleton(){
	 
	 private static LazySingleton instance = null;
	 private LazySingleton(){};
	 public synchronized static LazySingleton getInstance(){
		    if(instance == null){
		    	instance = new LazySingleton();
		    }
		    return instance;
	}

}

懒汉式单例-doublecheck模式(解决上述 synchronized引起的性能浪费问题 ,并加入volatile 保证其可见性)

public class LazyDoubleCheckSingleton(){

	private volatile static LazyDoubleCheckSingleton instance = null;
	private LazyDoubleCheckSingleton(){};
	public static LazyDoubleCheckSingleton getInstance(){
			if(instance == null){
					synchronized(LazyDoubleCheckSingleton.class){
						if(instance == null){
							instance = new LazyDoubleCheckSingleton();
						}
					}
			}
	}
}

懒汉式单例-静态内部类(算是单例模式里最优写法)

public class LazyInnerSingleton(){
	 
	 private LazyInnerSingleton（）{}；
	 private static class LazyHandle(){
		private static final LazyInnerSingleton instance = new LazyInnerSingleton();
	 }

	public static LazyInnerSingleton getInstance(){
		return LazyHandle.instance;
	}


}

上述单例都有共同的问题 。反射破坏及序列化破坏

反射 我们在其构造方法中做校验处理即可。那么序列化呢 ？

在其反序列化时， 通过源码查看ObjectInputStream 的 readObject方法

重要的是 hasReadResolveMethod();
在反序列化时会判断， 我们的类是不是有readResolve方法。
如果有这个方法，它回去jvm中查找对应的反序列化的类是否存在 。
如果jvm中有， 即返回这个。
所以只需要在 类中 加上一个 readResolve方法，即可以让反序列化回来的对象与jvm中的一致.

现在大家都应该听过，枚举单例.
它为什么最推荐呢？因为它天生不同，jdk已经对它考虑了 并发及 序列化问题。所以不用你管
enum是禁止反射 ，反序列化时如果是enum类 会自动去jvm中查找
最终要使用哪种单例模式，需要看你的实际业务需求。
附 :枚举单例

public enum EnumSingleton(){
	INSTANCE;
	private Object data;
	public Object getData(){
		return data;
	}    
	private EnumSingleton(){};
}