spring设计模式-单例模式
单例模式
：是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式
- 懒汉式单例模式：在类加载的时候就立即初始化，并且创建为单例对象，它绝对线程安全，线程还没出现的时候就实例化了
- 不可能存在访问安全问题。
- 优点：没有加任何锁，执行效率比较高，用户体验比懒汉式单例模式更好
- 缺点：类加载的时候就初始化，不管用不用都占着空间，浪费了内存。
饿汉式： public class HungrySingleton { private static HungrySingleton hungrySingleton=new HungrySingleton(); //另一种写法 private static HungrySingleton hungrySingleton1; static{ hungrySingleton1=new HungrySingleton(); } private HungrySingleton(){} public static HungrySingleton getInstance(){ return hungrySingleton; } } 懒汉式： /** * 特点：被外部类调用的时候，内部类才会被加载.缺点：线程不安全 */ public class LazySingleton { private LazySingleton(){} private static LazySingleton lazySingleton=null; public static LazySingleton getInstance(){ if (lazySingleton==null){ lazySingleton=new LazySingleton(); } return lazySingleton; } //方法一：线程不安全的办法，加锁,缺点：性能下降 public static synchronized LazySingleton getInstance1(){ if (lazySingleton==null){ lazySingleton=new LazySingleton(); } return lazySingleton; } //方法二：双重检验所：解决线程安全和性能问题(双重检验锁） public static LazySingleton getInstance2(){ if(lazySingleton==null){ synchronized (LazySingleton.class){ if(lazySingleton==null){ lazySingleton=new LazySingleton(); //1、分配内存给这个对象 //2、初始化对象 //3、设置lazysingleton指向刚分配的内存地址 } } } return lazySingleton; } } 内部类： package com.wanda.singleton; import java.lang.reflect.Constructor; /** * 这种形式兼顾了饿汉式内存浪费问题和synchronized性能问题 */ public class LazyInnerSingleton { // private LazyInnerSingleton(){} //修改后的构造方法 private LazyInnerSingleton(){ if(LazyHolder.lazy!=null){ throw new RuntimeException("不允许创建多个实例"); } } public static final LazyInnerSingleton getInstance(){ return LazyHolder.lazy; } //内部类在方法调用之前初始化，避免了线程不安全的问题 private static class LazyHolder{ private static final LazyInnerSingleton lazy=new LazyInnerSingleton(); } public static void main(String[] args) { //反射破坏单例情况,通过这种方式会创建两个不同的单例。可以在构造方法中做一些限制，一旦多次重复创建就抛出异常。 try { Class<?> clazz=LazyInnerSingleton.class; Constructor constructor=clazz.getDeclaredConstructor(null); //强制访问 constructor.setAccessible(true); Object o1=constructor.newInstance(); Object o2=constructor.newInstance(); System.out.println(o1==o2); }catch (Exception e){ e.printStackTrace(); } } } 序列化破坏单例 package com.wanda.singleton; import java.io.*; //一个单例对象创建后，有时需要序列化到磁盘，下次使用时在从磁盘读入，进行反序列化，反序列华的对象会重新分配内存 //即重新创建，如果序列化的对象是单例，就违背了单例的意义。 public class SeriableSingleton implements Serializable { public static final SeriableSingleton INSTANCE=new SeriableSingleton(); private SeriableSingleton(){} public static SeriableSingleton getInstance(){ return INSTANCE; } private Object readResolve(){ return INSTANCE; } public static void main(String[] args) { SeriableSingleton s1=null; SeriableSingleton s2=SeriableSingleton.getInstance(); FileOutputStream fos=null; try { fos=new FileOutputStream("seriablesingleton.obj"); ObjectOutputStream os=new ObjectOutputStream(fos); os.writeObject(s2); os.flush(); os.close(); FileInputStream fis=new FileInputStream("seriablesingleton.obj"); ObjectInputStream ois=new ObjectInputStream(fis); s1=(SeriableSingleton) ois.readObject(); ois.close(); System.out.println(s1); System.out.println(s2); System.out.println(s1==s2);//false 解决方法：加上readResolve方法 }catch (Exception e){ } } } 枚举： package com.wanda.singleton; import java.io.*; //一个单例对象创建后，有时需要序列化到磁盘，下次使用时在从磁盘读入，进行反序列化，反序列华的对象会重新分配内存 //即重新创建，如果序列化的对象是单例，就违背了单例的意义。 public class SeriableSingleton implements Serializable { public static final SeriableSingleton INSTANCE=new SeriableSingleton(); private SeriableSingleton(){} public static SeriableSingleton getInstance(){ return INSTANCE; } private Object readResolve(){ return INSTANCE; } public static void main(String[] args) { SeriableSingleton s1=null; SeriableSingleton s2=SeriableSingleton.getInstance(); FileOutputStream fos=null; try { fos=new FileOutputStream("seriablesingleton.obj"); ObjectOutputStream os=new ObjectOutputStream(fos); os.writeObject(s2); os.flush(); os.close(); FileInputStream fis=new FileInputStream("seriablesingleton.obj"); ObjectInputStream ois=new ObjectInputStream(fis); s1=(SeriableSingleton) ois.readObject(); ois.close(); System.out.println(s1); System.out.println(s2); System.out.println(s1==s2);//false 解决方法：加上readResolve方法 }catch (Exception e){ } } } 容器式： package com.wanda.singleton; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * 容器式单例模式:非线程安全 */ public class ContainerSingleton { private ContainerSingleton(){} private static Map<String,Object> map=new ConcurrentHashMap<>(); public static Object getBean(String clazzName){ synchronized (map){ if(!map.containsKey(clazzName)){ Object obj=null; try{ obj=Class.forName(clazzName).newInstance(); map.put(clazzName,obj); }catch (Exception e){ e.printStackTrace(); } return obj; }else{ return map.get(clazzName); } } } }