一、什么是单例模式？
单例：一个类模版，在整个系统运行过程中，只允许产生一个事例（有且只有一个）。
二、保存单例的技术方案有哪些？
- 饿汉式：在实例使用之前，不管用不用，都先new出来，避免了线程安全问题；
/**
* @ather: lucksheep
* @date: 2018/8/6 19:46
* @description: 饿汉式
*/
public class Hungry {
private Hungry(){}
//先静态、后动态
//先属性、后方法
//先上后下
private static final Hungry hungry=new Hungry();
public static Hungry getInstance(){
return hungry;
}
}
- 懒汉式：默认加载的时候不实例化，在需要用到的时候才实例化,延迟加载；
第一种：
/**
* @ather: lucksheep
* @date: 2018/8/7 11:18
* @description: 懒汉式
*/
public class LazyOne {
private LazyOne(){}
private static LazyOne lazy=null;
public static LazyOne getInstance(){
if(lazy==null){
lazy=new LazyOne();
}
return lazy;
}
}
第二种：
/**
* @ather: lucksheep
* @date: 2018/8/9 14:25
* @description:
*/
public class LazyTwo {
private LazyTwo(){}
private static LazyTwo lazy=null;
public static synchronized LazyTwo getInstance(){
if(lazy==null){
lazy=new LazyTwo();
}
return lazy;
}
}
第三种：
/**
* @ather: lucksheep
* @date: 2018/8/9 14:25
* @description:
*/
public class LazyThree {
private static boolean initialized = false;
//默认使用LazyThree的时候，先初始化内部类
//如果没使用，内部类是不加载的
private LazyThree(){
//防止反射
synchronized (LazyThree.class){
if(initialized == false){
initialized = !initialized;
}else{
throw new RuntimeException("单例已被侵犯，不给你看！");
}
}
}
public static final synchronized LazyThree getInstance(){
return LazyHolder.lazy;
}
private static class LazyHolder{
private static final LazyThree lazy=new LazyThree();
}
}
- 注册登记式：每使用一次，都往一个固定的容器中去注册并且将使用过的对象进行缓存，下次去取对象的时候，就直接从缓存中取值，以保证每次获取的都是同一个对象；IOC中的单例模式就是典型的注册登记式单例
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @ather: lucksheep
* @date: 2018/8/10 15:48
* @description: 注册登记式
*/
public class RegisterMaps {
private static Map<String,Object> registerMaps=new HashMap<>();
//如果要安全的 ConcurrentHashMap
public static RegisterMaps getInstance(String name){
if(null == name){
name = RegisterMaps.class.getName();
}
if(registerMaps.get(name) == null){
registerMaps.put(name,new RegisterMaps());
}
return (RegisterMaps) registerMaps.get(name);
}
}
- 枚举式：这个很简单我就不说了。
/**
* @ather: lucksheep
* @date: 2018/8/10 15:57
* @description: 枚举
*/
public enum RegisterEnum {
ONE,TWO,Three;
}
- 序列化与反序列化单例：如果要保证单例安全，只需要重写 private Object readResolve(){}这个方法。
/**
* @ather: lucksheep
* @date: 2018/8/10 16:07
* @description: 序列化单例
*/
public class Serializes implements Serializable {
private static final long serialVersionUID = 3239595067725719650L;
private Serializes(){}
public final static Serializes serializes=new Serializes();
public static Serializes getInstance(){
return serializes;
}
/**
* 加上可以保证单例是安全的
* 原因：序列化与反序列化中的一个协议，为了实现实例化后，
* 对象重复利用，它可以实现 readResolve() 这个方法，这个方法是JVM自动去调用的
* @return
*/
private Object readResolve(){
return serializes;
}
}
