设计模式：单列模式

----《spring 5 核心原理》 笔记  

单列singleton 什么意思，就是这个应用在使用的过程中jvm里面 对于类a，只能有一个实例，别人无法再去new它。

  那么这里就需要吧new的权限，交给管理者。new的权限，不能给用户，如何不能让用户new出来，使用private 够找方法。结合static ，让new的功能，交给类自己来实现，然后类只需要把自己new出来的对象返回就可以了， 用户只拥有调配的权利。

单列第一版本：饿汉单例

public class HungrySingleton {
      private static final HungrySingleton hu=new HungrySingleton();
      private HungrySingleton() {}
      public static HungrySingleton getInstance() {
            return hu;
      }
      public void show() {
            System.out.println("hello ...");
      }
}

public class HungrySingleton {
      private static final HungrySingleton hu;
      static {
            hu=new HungrySingleton();
      }
      private HungrySingleton() {}
      public HungrySingleton getInstance() {
            return hu;
      }
}

测试一下：

public static void main(String []args) {
            HungrySingleton h=HungrySingleton.getInstance();
            HungrySingleton w=HungrySingleton.getInstance();
            System.out.println(h.toString()+" \n"+w.toString());
            h.show();
      }

可以看到，两次调用，其实是调用的同一个对象，由于private 私有构造函数，只有在本类里面，才能使用构造函数，其他类里面是无法调用构造函数的。

  这里我们发现，这个类的创建是在类加载的时候立即初始化的，它绝对线程安全，但是缺点就是，不管有没有使用，它都一直存在与jvm中，稍稍有点浪费空间。这种适用于单列对象比较少的情况下（如果大把的对象是单列的，那么就有点耗资源）

第二种：懒汉单列模式：

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

  我们首先想到的当然是在调用的时候 new出来，我们在new之前判断一下，不就可以了吗，但是！！！这里出现了线程安全问题，如果两个线程同时进入了if(ls==null) 有一个判断为true，然后线程时间到了，去排队，然后第二个线程，同样也为true，那么最后，两个会new两次。所以这里要上锁。synchronized。

  这个锁上在调用方法上面之后，出现了一个资源太耗费的问题，这是锁自身的原因，我们可以改用双重检查锁

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

， 这样有什么好处：那就是已经初始化了，可以直接调用，那就不用去上锁，等锁了。

  还有更好的方式吗？上锁 始终要消耗cpu的资源。

public class LazySingleton {
	private LazySingleton() {}
	public static final LazySingleton getInstance() {
		return LazyHolder.lazy;
	}
	private static class LazyHolder{
		private static final LazySingleton lazy=new LazySingleton();
	}
}

使用匿名内部类的方式，在使用LazySingleton的时候，默认会先初始化内部类，而内部类的特点，就是集合了饿汉单列的特点，可以保障线程安全，而不使用LazySingleton的时候，就不需要初始化这个类。

-------------------------------------

两种基本的单列模式，已经介绍完毕。

但是，如果只有反射 暴力破解呢？我们看结果吧：

public class text {
	public static void main(String []args) {
		try {
			Class<?> clazz=LazySingleton.class;
			Constructor c=clazz.getDeclaredConstructor(null);
			c.setAccessible(true);
			Object o1=c.newInstance();
			Object o2=c.newInstance();
			System.out.print(o1.toString()+"\n"+o2.toString());
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
}

显然，通过暴力破解，可以避开单列，怎么解决呢？这个是构造方法的问题吧，所以我们需要在构造方法上，使用懒汉加载的方式，对调用构造的时候，进行判断，观察是否已经被创建过。

private LazySingleton () {
		if(lazy.la!=null)
			throw new RuntimeException("不允许 创建多个实例");
	}

但是，如果经历 序列化呢，把一个类，通过序列化写入磁盘（从内存），然后下一次使用磁盘中读取进行反序列化，将其转为内存中的对象，这个反序列化的对象，会重新分配内存，即重新创建。

public static void main(String []args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
		HungrySingleton s1=null;
		HungrySingleton s2=HungrySingleton.getInstance();
		
		FileOutputStream fos=null;
		try {
			fos=new FileOutputStream("HungrySingleton.obj");
			ObjectOutputStream oos=new ObjectOutputStream(fos);
			oos.writeObject(s2);
			oos.flush();
			oos.close();
			
			FileInputStream fis=new FileInputStream("HungrySingleton.obj");
			ObjectInputStream ois=new ObjectInputStream(fis);
			s1=(HungrySingleton)ois.readObject();
			ois.close();
			System.out.println(s1==s2);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}

结果：

如何解决呢？：只需要添加readResolve()方法即可。

private Object readResolve() {
		return hu;
	}

背后的原理是什么呢？为什么加一个这个方法，就可以确保序列化之后，还是能保证单列。

因为jdk中，readObject里面使用反射判断 是否 有这个readResolve方法，如果有则返回true，返回true就不会返回新创建的类，而是继续使用原因的类。问题又来了，如果并发高，那么这里还是会创建很多类，虽然没有返回，但是消耗了资源，如何从根本上解决问题呢？

------------------------------------------

注册式单列模式：

枚举单列模式：

 

public enum EnumSingleton {
	instance;
	private Object data;
	public Object getData() {
		return data;
	}
	public void setData(Object data) {
		this.data=data;
	}
	public static EnumSingleton getInstance() {
		return instance;
	}
}