spring设计模式-单例模式

单例模式是指确保一个类在任何情况下都绝对只有一个实例并提供一个全局访问点。单例模式是创建型模式懒汉式单例模式在类加载的时候就立即初始化并且创建为单例对象它绝对线程安全线程还没出现的时候就实例化了不可能存在访问安全问题。优点没有加任何锁执行效率比较高用户体验比懒汉式单例模式更好缺点类加载的时候就初始化不管用不用都占着空间浪费了内存。饿汉式 public class HungrySingleton { private static HungrySingleton hungrySingletonnew HungrySingleton(); //另一种写法 private static HungrySingleton hungrySingleton1; static{ hungrySingleton1new HungrySingleton(); } private HungrySingleton(){} public static HungrySingleton getInstance(){ return hungrySingleton; } } 懒汉式 /** * 特点被外部类调用的时候内部类才会被加载.缺点线程不安全 */ public class LazySingleton { private LazySingleton(){} private static LazySingleton lazySingletonnull; public static LazySingleton getInstance(){ if (lazySingletonnull){ lazySingletonnew LazySingleton(); } return lazySingleton; } //方法一线程不安全的办法加锁,缺点性能下降 public static synchronized LazySingleton getInstance1(){ if (lazySingletonnull){ lazySingletonnew LazySingleton(); } return lazySingleton; } //方法二双重检验所解决线程安全和性能问题(双重检验锁 public static LazySingleton getInstance2(){ if(lazySingletonnull){ synchronized (LazySingleton.class){ if(lazySingletonnull){ lazySingletonnew 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 lazynew LazyInnerSingleton(); } public static void main(String[] args) { //反射破坏单例情况,通过这种方式会创建两个不同的单例。可以在构造方法中做一些限制一旦多次重复创建就抛出异常。 try { Class? clazzLazyInnerSingleton.class; Constructor constructorclazz.getDeclaredConstructor(null); //强制访问 constructor.setAccessible(true); Object o1constructor.newInstance(); Object o2constructor.newInstance(); System.out.println(o1o2); }catch (Exception e){ e.printStackTrace(); } } } 序列化破坏单例 package com.wanda.singleton; import java.io.*; //一个单例对象创建后有时需要序列化到磁盘下次使用时在从磁盘读入进行反序列化反序列华的对象会重新分配内存 //即重新创建如果序列化的对象是单例就违背了单例的意义。 public class SeriableSingleton implements Serializable { public static final SeriableSingleton INSTANCEnew SeriableSingleton(); private SeriableSingleton(){} public static SeriableSingleton getInstance(){ return INSTANCE; } private Object readResolve(){ return INSTANCE; } public static void main(String[] args) { SeriableSingleton s1null; SeriableSingleton s2SeriableSingleton.getInstance(); FileOutputStream fosnull; try { fosnew FileOutputStream(seriablesingleton.obj); ObjectOutputStream osnew ObjectOutputStream(fos); os.writeObject(s2); os.flush(); os.close(); FileInputStream fisnew FileInputStream(seriablesingleton.obj); ObjectInputStream oisnew ObjectInputStream(fis); s1(SeriableSingleton) ois.readObject(); ois.close(); System.out.println(s1); System.out.println(s2); System.out.println(s1s2);//false 解决方法加上readResolve方法 }catch (Exception e){ } } } 枚举 package com.wanda.singleton; import java.io.*; //一个单例对象创建后有时需要序列化到磁盘下次使用时在从磁盘读入进行反序列化反序列华的对象会重新分配内存 //即重新创建如果序列化的对象是单例就违背了单例的意义。 public class SeriableSingleton implements Serializable { public static final SeriableSingleton INSTANCEnew SeriableSingleton(); private SeriableSingleton(){} public static SeriableSingleton getInstance(){ return INSTANCE; } private Object readResolve(){ return INSTANCE; } public static void main(String[] args) { SeriableSingleton s1null; SeriableSingleton s2SeriableSingleton.getInstance(); FileOutputStream fosnull; try { fosnew FileOutputStream(seriablesingleton.obj); ObjectOutputStream osnew ObjectOutputStream(fos); os.writeObject(s2); os.flush(); os.close(); FileInputStream fisnew FileInputStream(seriablesingleton.obj); ObjectInputStream oisnew ObjectInputStream(fis); s1(SeriableSingleton) ois.readObject(); ois.close(); System.out.println(s1); System.out.println(s2); System.out.println(s1s2);//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 MapString,Object mapnew ConcurrentHashMap(); public static Object getBean(String clazzName){ synchronized (map){ if(!map.containsKey(clazzName)){ Object objnull; try{ objClass.forName(clazzName).newInstance(); map.put(clazzName,obj); }catch (Exception e){ e.printStackTrace(); } return obj; }else{ return map.get(clazzName); } } } }