----《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;
}
}