设计模式03-单例模式
1.3.1.设计模式03-单例模式【上】
时长：1h33min
课程目标：
》单例模式的应用场景
》IDEA下的多线程调试方式
》保证线程安全的单例模式策略
》掌握反射暴力攻击单例解决方案及原理分析
》序列化破坏单例的原理及解决方案
》掌握常见的单例模式写法
》原型模式的应用场景及常用写法
学习目的：
》深入掌握单例模式
》解决面试题
1.单例模式的定义
单例模式，Singleton Pattern.
定义：
是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
隐藏所有的构造方法【私有】
创建创建型模式。
1.1.适用场景
确保在任何情况下都只有一个实例。
生活中单例体现：
国家主席，公司ceo,部门经理。
代码中单例类：
ServletContext,ServletConfig,ApplicationContext,DBPool
为什么它是单例的呢？
如：配置文件，只能有一个，否则该使用谁呢。【唯一性主权】
2.单例模式常见用法
1.饿汉式单例
2.懒汉式单例
3.注册式单例
4.ThreadLocal单例
2.1.饿汉式单例
人很饿------》着急吃饭---》在类首次加载时创建实例【用不用，先吃饱再说】
2.1.1.代码示例
package com.wf.singleton; /** * @ClassName HungrySingleton * @Description 饿汉式单例 * @Author wf * @Date 2020/4/29 17:28 * @Version 1.0 */ public class HungrySingleton { //首次加载静态成员 public static final HungrySingleton singleton = new HungrySingleton(); //构造私有 private HungrySingleton(){} //全局访问点 public static HungrySingleton getInstance(){ return singleton; } }
第二种写法：
package com.wf.singleton; /** * @ClassName HungryStaticSingleton * @Description 饿汉式单例---静态块初始化 * @Author wf * @Date 2020/4/29 17:31 * @Version 1.0 */ public class HungryStaticSingleton { //final保证反射不会改变实例 private static final HungryStaticSingleton instance; private HungryStaticSingleton(){} static{ instance = new HungryStaticSingleton(); } public static HungryStaticSingleton getInstance(){ return instance; } }
2.1.2.优缺点总结
优点：
执行效率高，性能高【无锁】
缺点：
可能生成内存浪费，因为实例不被使用，也进行new .
说明：
这种写法，只能在小范围内使用。
2.2.懒汉式单例
人很懒------不着急-----等到使用时再创建
2.2.1.示例代码
package com.wf.singleton; /** * @ClassName LazySimpleSingleton * @Description 懒汉式单例 * @Author wf * @Date 2020/4/29 17:43 * @Version 1.0 */ public class LazySimpleSingleton { private static LazySimpleSingleton instance; private LazySimpleSingleton(){} public static LazySimpleSingleton getInstance(){ if(null == instance) { instance = new LazySimpleSingleton(); } return instance; } }
2.2.2.总结
优点：
节省内存空间，使用时再创建实例。
缺点：
线程不安全。性能差。
为什么会线程不安全呢？
线程不安全来自于getInstance方法，方法的调用者最终归结到线程。
当出现多个线程，同时调用getInstance方法时，线程间会抢占资源。如下所示：
这是理论上的分析。下面在idea中进行代码调试，说明这种线程不安全性。
A.多线程调试线程安全性
【1】创建测试类
package com.wf.singleton; import org.junit.Test; public class LazySimpleSingletonTest { @Test public void getInstance() { Thread t1 = new Thread(new ExecutorThread()); Thread t2 = new Thread(new ExecutorThread()); t1.start(); t2.start(); System.out.println("end"); } }
【2】测试任务类
package com.wf.singleton; /** * @ClassName ExecutorThread * @Description 创建一个测试task * @Author wf * @Date 2020/4/29 18:53 * @Version 1.0 */ public class ExecutorThread implements Runnable { @Override public void run() { LazySimpleSingleton instance = LazySimpleSingleton.getInstance(); System.out.println(Thread.currentThread().getName() +":"+instance); } }
在任务类中，run方法，访问单例类，获取实例。并打印实例hash地址。当两个线程，打印hash地址相同时，
说明只有一个实例，是单例的。
不存在线程安全问题，否则，是线程非安全的。
B.调试过程
【1】直接运行测试类，查看结果：
明显，可以看到，hash地址不同，创建现两个实例。
多次运行，可以发现，有时只会创建一个实例。这时，线程执行的随机性决定的。
我们可以得出结论，getInstance方法是线程非安全的。
【2】断点调试之前，理论上结果分析
从上面的运行，有两种结果：
》同一实例
a,两个线程顺序执行
b.两个线程都进入getInstance方法，if分支【后者覆盖前者】
第一个线程，创建出一个实例instance1
第二个线程，稍后第二个线程，也进入if,并执行new实例instance2,instance2就把instance1给覆盖掉了
最后，得到的实例都是instance2
》不同实例
同时进入if条件，按顺序返回
第一个线程new后，快速执行结束方法，打印实例1
第二个线程，再次new，打印实例2
【3】断点调试
断点设置如下：
注意：
3个断点，都设置成Thread多线程运行模式。设置方法：右击断点，弹出设置框，切换到Thread模式，然后Done.
然后，debug运行测试类：
在Frames窗口下，可以查看到所有的线程。现在，几个线程都是running状态，表示线程都抢到cpu资源，但是什么时候，
执行任务，由cpu来决定。
切换到Thread-0,然后执行下一步，先让它按正常状态执行。
Thread-0线程，先顺序执行完成，并打印.
然后，切换到第二个线程Thread-1,让他进入getInstance方法，经过if判断，由于instance已经创建，非null,条件不成立。
所以，两个线程创建一个实例。如下所示：
可以看到，最后打印相同的结果。
第二种情况 ：调试后者覆盖前者
先让两个线程都进入if分支，如下所示：
Thread-0线程进入：
Thread-1线程进入：
然后,再切换到Thread-0,先执行new语句，如下所示：
再切换到，线程1，执行new操作，如下所示：
再切换到，Thread-0执行完成，打印结果。
再让Thread-1执行完成，打印结果：
第三种情况：不同实例
首先，让两个线程都进入getInstance方法的if分支。
然后，先让Thread-0线程执行完，并打印。
最后，Thread-1线程，再执行完成，并打印，如下所示：
出现不同的实例。
2.2.3.解决线程不安全
解决方案：
使用sycronized关键字，加同步锁，如下所示：
package com.wf.singleton; /** * @ClassName LazySimpleSingleton * @Description 懒汉式单例 * @Author wf * @Date 2020/4/29 17:43 * @Version 1.0 */ public class LazySimpleSingleton { private static LazySimpleSingleton instance; private LazySimpleSingleton(){} public synchronized static LazySimpleSingleton getInstance(){//使用synchronized解决线程安全性问题 if(null == instance) { instance = new LazySimpleSingleton(); } return instance; } }
问题解决了。
2.2.3.1.debug分析synchronized关键字作用
先让Thread-0线程进入if分支，如下所示：
可以观察到，两个线程的状态均为Running.
再切换到Thread-1线程，也试图让它进入getInstance方法：
可以发现，Thread-1线程进不去getInstance方法了，并且线程状态变为Monitor.
也就是说Thread-1线程阻塞，开始等待，直到Thread-0线程执行完getInstance方法。
然后，让Thread-0线程执行完，并打印，如下所示：
然后，切换到Thread-1线程，如下所示：
可以发现，当Thread-0线程执行后，切换到Thread-1线程，线程状态又恢复到Running状态，并进入getInstance方法。
所以，我们得出结论：
synchronized关键字，是用来控制资源只能被一个线程占用，实现互斥特性。
虽然，解决了线程安全性问题，但是代码性能受到限制。性能差。
为了解决性能问题，提出“双重检查”单例的解决方案。
2.2.4.双重检查的单例模式
2.2.4.1.代码示例如下：
package com.wf.singleton; /** * @ClassName LazyDoubleCheckSingleton * @Description 双重检查--懒汉式单例 * @Author wf * @Date 2020/4/30 12:41 * @Version 1.0 */ public class LazyDoubleCheckSingleton { //volatile关键字解决指令重排序问题 private volatile static LazyDoubleCheckSingleton instance; private LazyDoubleCheckSingleton(){} public static LazyDoubleCheckSingleton getInstance(){ if(null == instance){//第一次检查，是否阻塞，只阻塞第一次new synchronized (LazyDoubleCheckSingleton.class) { //第二次检查，检查是否重复创建实例 if (null == instance) { instance = new LazyDoubleCheckSingleton(); //会有指令重排序问题 } } } return instance; } }
当在getInstance方法内部使用双重检查机制，解决了懒汉式单例的性能问题。
但它存在指令重排序问题。
创建一个对象包含下面两个过程：
1、类构造器完成类初始化（分配内存、赋予默认值）
2、类实例化（赋予给定值）
在java中，当new一个实例时，会存在两块内存地址的处理：
》创建后的实例会指向堆内存
》成员赋值会指向栈内存
两块内存的操作，先后顺序具有随机性，因此，可能会产生指令重排序问题。
不过，没关系，java提供了volatile关键字，解决指令重排序问题。
2.2.4.2.总结
双重检查机制，解决了线程安全性问题，也提升程序性能。
但是，两个if判断，很容易让人迷惑，可读性差，代码不够优雅。
1.3.2.设计模式03-单例模式【下】
时长：1h6min
2.2.5.懒汉式-静态内部类实现单例
代码如下：
package com.wf.singleton; /** * @ClassName LazyStaticInnerClassSingleton * @Description 懒汉式-静态内部类实现单例 * @Author wf * @Date 2020/4/30 13:11 * @Version 1.0 */ public class LazyStaticInnerClassSingleton { private LazyStaticInnerClassSingleton(){} private static LazyStaticInnerClassSingleton getInstance(){ return LazyHolder.instance; } //静态内部类 private static class LazyHolder{ private static LazyStaticInnerClassSingleton instance = new LazyStaticInnerClassSingleton(); } }
为什么这种方式是懒汉式呢，感觉很类似饿汉式单例？
类加载机制，默认加载classpath下的*.class文件，而内部类在classpath下编译为XXX$LazyHolder.class【主类$内部类.class】
所以，首次加载类时，不会加载内部类。只有当程序中使用到内部类时，才会加载内部类。
总结：
优点：写法优雅，很好利用java本身的语法特点，性能高，避免内存浪费。
缺点：无法避免反射破坏。
实际上，前面的几种单例写法，都无法避免反射破坏。
2.2.6.反射破坏单例测试
为什么反射会破坏单例呢？
因为代码中单例的实现时，基于构造器私有。如果通过反射能拿到类的实例，不就被破坏了吗。
2.2.6.1.测试代码
package com.wf.singleton; import java.lang.reflect.Constructor; /** * @ClassName ReflectTest * @Description 反射破坏单例 * @Author wf * @Date 2020/4/30 13:52 * @Version 1.0 */ public class ReflectTest { public static void main(String[] args) { Class<?> clazz = LazyStaticInnerClassSingleton.class; try { Constructor<?> c = clazz.getDeclaredConstructor(null); System.out.println(c); c.setAccessible(true);//强制 Object obj = c.newInstance();//通过反射，成功绕过单例类的全局访问点，创建实例 Object obj1 = c.newInstance(); System.out.println(obj); System.out.println(obj1); } catch (Exception e) { e.printStackTrace(); } } }
测试结果如下：
很明显，单例特性已经被破坏。
2.2.6.2.如何防止反射破坏单例
解决方法，是在构造器中做非空判断，如果非空，抛异常，提示不允许非法访问。
代码如下：
package com.wf.singleton; /** * @ClassName LazyStaticInnerClassSingleton * @Description 懒汉式-静态内部类实现单例 * @Author wf * @Date 2020/4/30 13:11 * @Version 1.0 */ public class LazyStaticInnerClassSingleton { private LazyStaticInnerClassSingleton(){ //防止反射破坏单例 if(null != LazyHolder.instance){ throw new RuntimeException("不允许非法访问"); } } private static LazyStaticInnerClassSingleton getInstance(){ return LazyHolder.instance; } //静态内部类 private static class LazyHolder{ private static LazyStaticInnerClassSingleton instance = new LazyStaticInnerClassSingleton(); } }
然后，执行测试：
反射破坏单例，成功解决。
总结：
这种在构造器上做判断，抛异常的方式。使代码看起来很奇怪，代码又不够优雅了。程序可读性变差。
那么，什么才是优雅的单例写法呢？
答案是：注册式单例，它是《java Effective》一书中推荐的，最为优雅的单例写法。
3.注册式单例
定义：
将每一个实例都缓存到统一的容器中，使用唯一标识获取实例。
3.1.枚举式单例
枚举式单例，属于一种特殊的注册式单例。
java中提供enum关键字，标识一个类为枚举类。底层它是继承Eunm抽象类。
3.1.1.示例代码如下
package com.wf.singleton.register; /** * @ClassName EnumSingleton * @Description 枚举式单例 * @Author wf * @Date 2020/4/30 14:16 * @Version 1.0 */ public enum EnumSingleton { INSTANCE; //枚举中可以自定义属性 private Object data; public static EnumSingleton getInstance(){ return INSTANCE; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } }
枚举式单例应该怎么使用呢？
创建一个测试类，模拟客户端调用
package com.wf.singleton; import com.wf.singleton.register.EnumSingleton; import java.lang.reflect.Constructor; /** * @ClassName EnumSingletonTest * @Description TODO * @Author wf * @Date 2020/4/30 14:21 * @Version 1.0 */ public class EnumSingletonTest { public static void main(String[] args) { EnumSingleton instance = EnumSingleton.getInstance(); instance.setData("设置值"); //测试反射破坏 Class<?> clazz = EnumSingleton.class; try { Constructor<?> c = clazz.getDeclaredConstructor(null); Object obj1 = c.newInstance(); Object obj2 = c.newInstance(); System.out.println("obj1:"+obj1); System.out.println("obj2:"+obj2); } catch (Exception e) { e.printStackTrace(); } } }
测试结果如下：
可以发现，进行反射破坏时，代码抛异常了。异常信息如下：
java.lang.NoSuchMethodException: com.wf.singleton.register.EnumSingleton.<init>()
at java.lang.Class.getConstructor0(Class.java:3082)
at java.lang.Class.getDeclaredConstructor(Class.java:2178)
at com.wf.singleton.EnumSingletonTest.main(EnumSingletonTest.java:22)
通过查看源码，Enum类只有一个带2个参数的构造器，那么反射破坏是不是可以基于此创建实例呢，修改代码如下：
package com.wf.singleton; import com.wf.singleton.register.EnumSingleton; import java.lang.reflect.Constructor; /** * @ClassName EnumSingletonTest * @Description TODO * @Author wf * @Date 2020/4/30 14:21 * @Version 1.0 */ public class EnumSingletonTest { public static void main(String[] args) { EnumSingleton instance = EnumSingleton.getInstance(); instance.setData("设置值"); //测试反射破坏 Class<?> clazz = EnumSingleton.class; try { Constructor<?> c = clazz.getDeclaredConstructor(String.class,int.class); System.out.println(c);//可以得到 c.setAccessible(true); Object obj = c.newInstance(); } catch (Exception e) { e.printStackTrace(); } } }
测试结果，报错。提示 不允许反射破坏。
为什么这样呢？意味着枚举类，没有getDeclaredConstructor方法。
3.1.2.查看枚举类的源码Enum
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; }
可以发现，Enum类中并不存在无参构造，只有一个带2个参数的构造器。
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { if (!override) { if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { Class<?> caller = Reflection.getCallerClass(); checkAccess(caller, clazz, null, modifiers); } } //修饰符如果是Enum枚举，不允许反射调用 if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); ConstructorAccessor ca = constructorAccessor; // read volatile if (ca == null) { ca = acquireConstructorAccessor(); } @SuppressWarnings("unchecked") T inst = (T) ca.newInstance(initargs); return inst; }
public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) { T result = enumType.enumConstantDirectory().get(name); if (result != null) return result; if (name == null) throw new NullPointerException("Name is null"); throw new IllegalArgumentException( "No enum constant " + enumType.getCanonicalName() + "." + name); } Map<String, T> enumConstantDirectory() { if (enumConstantDirectory == null) { T[] universe = getEnumConstantsShared(); if (universe == null) throw new IllegalArgumentException( getName() + " is not an enum type"); Map<String, T> m = new HashMap<>(2 * universe.length); for (T constant : universe) m.put(((Enum<?>)constant).name(), constant); enumConstantDirectory = m; } return enumConstantDirectory; } //定义map容器 private volatile transient Map<String, T> enumConstantDirectory = null;
3.1.3.总结
对于枚举来说，只要实例创建完成，就会被当成常量，存入map容器中。
不管用不用，都会存在。
所以，它是一种饿汉式单例。可能造成内存浪费。不能大批量创建对象。
优点：
代码优雅，底层防止反射破坏。线程安全。
因为它不能大量创建对象，所以，在spring中并没有使用枚举来实现单例。
而是基于枚举的设计思想，spring创建ioc容器来实现单例。
3.2.容器式单例
3.2.1.示例代码
package com.wf.singleton; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * @ClassName ContainerSingleton * @Description 容器式单例 * @Author wf * @Date 2020/4/30 19:37 * @Version 1.0 */ public class ContainerSingleton { private ContainerSingleton(){} private static Map<String,Object> iocMap = new ConcurrentHashMap<>(); public static Object getInstance(String className){ if(!iocMap.containsKey(className)){ try { Object instance = Class.forName(className).newInstance(); iocMap.put(className,instance); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } return iocMap.get(className); } }
3.2.2.测试代码
package com.wf.singleton; /** * @ClassName ContainerSingletonTest * @Description TODO * @Author wf * @Date 2020/4/30 19:42 * @Version 1.0 */ public class ContainerSingletonTest { public static void main(String[] args) { Object inst1 = ContainerSingleton.getInstance("com.wf.singleton.User"); Object inst2 = ContainerSingleton.getInstance("com.wf.singleton.User"); System.out.println(inst1); System.out.println(inst2); } }
package com.wf.singleton; /** * @ClassName User * @Description TODO * @Author wf * @Date 2020/4/30 19:43 * @Version 1.0 */ public class User { }
测试结果，如下：
3.2.3.总结
容器式单例，可以解决大量创建单例对象的问题。但它存在线程安全性问题。
那么，如何解决线程安全性问题呢？【可以从spring中寻找解决方案】，使用synchnonized双重检查锁来解决。
3.3.序列化破坏单例
3.3.1.什么是序列化和反序列化？
把内存中的对象状态，转换为字节码形式，然后再把字节码通过IO流输出，写到磁盘文件，保存到一个文件中。
实现永久化保存的这个过程，就是 序列化。
反之，再次使用时，从磁盘文件，读取内容到内存中，称为反序列化。
3.3.2.序列化破坏单例的代码示例
java中实现序列化，只需要实现Serialzable接口。
package com.wf.singleton; import java.io.Serializable; /** * @ClassName SerializableSingleton * @Description 序列化破坏单例示例 * @Author wf * @Date 2020/4/30 20:03 * @Version 1.0 */ public class SerializableSingleton implements Serializable { private static final SerializableSingleton instance = new SerializableSingleton(); private SerializableSingleton(){} public static SerializableSingleton getInstance(){ return instance; } /* private Object readResolve(){ return instance; }*/ }
创建测试类：
package com.wf.singleton; import java.io.*; /** * @ClassName SerializableSingletonTest * @Description TODO * @Author wf * @Date 2020/4/30 20:08 * @Version 1.0 */ public class SerializableSingletonTest { public static void main(String[] args) { SerializableSingleton s1 = null; SerializableSingleton s2 = SerializableSingleton.getInstance(); FileOutputStream fos = null; try{ fos = new FileOutputStream("serializableSingleton.obj"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(s2); oos.flush(); oos.close(); FileInputStream fis = new FileInputStream("serializableSingleton.obj"); ObjectInputStream ois = new ObjectInputStream(fis); s1 = (SerializableSingleton) ois.readObject(); ois.close(); System.out.println(s1); System.out.println(s2); System.out.println(s1==s2); }catch (Exception e){ } } }
测试结果如下：
显然，单例被破坏了。
如何解决序列化破坏单例的问题呢，在单例类中增加readResolve方法如下：
package com.wf.singleton; import java.io.Serializable; /** * @ClassName SerializableSingleton * @Description 序列化破坏单例示例 * @Author wf * @Date 2020/4/30 20:03 * @Version 1.0 */ public class SerializableSingleton implements Serializable { private static final SerializableSingleton instance = new SerializableSingleton(); private SerializableSingleton(){} public static SerializableSingleton getInstance(){ return instance; } //防止序列化破坏单例 private Object readResolve(){ return instance; } }
再进行测试，结果如下：
为什么，增加readResolve方法，就解决这个问题了呢？
创建对象,是由java.io.ObjectInputStream#readObject方法来完成的。下面查看它的源码。
3.3.2.readObject源码分析
public final Object readObject() throws IOException, ClassNotFoundException { if (enableOverride) {//允许重写 return readObjectOverride(); } // if nested read, passHandle contains handle of enclosing object int outerHandle = passHandle; try { Object obj = readObject0(false);//核心逻辑 handles.markDependency(outerHandle, passHandle); ClassNotFoundException ex = handles.lookupException(passHandle); if (ex != null) { throw ex; } if (depth == 0) { vlist.doCallbacks(); } return obj; } finally { passHandle = outerHandle; if (closed && depth == 0) { clear(); } } } private Object readObject0(boolean unshared) throws IOException { boolean oldMode = bin.getBlockDataMode(); if (oldMode) { int remain = bin.currentBlockRemaining(); if (remain > 0) { throw new OptionalDataException(remain); } else if (defaultDataEnd) { /* * Fix for 4360508: stream is currently at the end of a field * value block written via default serialization; since there * is no terminating TC_ENDBLOCKDATA tag, simulate * end-of-custom-data behavior explicitly. */ throw new OptionalDataException(true); } bin.setBlockDataMode(false); } byte tc; while ((tc = bin.peekByte()) == TC_RESET) { bin.readByte(); handleReset(); } depth++; totalObjectRefs++; try { switch (tc) { case TC_NULL: return readNull(); case TC_REFERENCE: return readHandle(unshared); case TC_CLASS: return readClass(unshared); case TC_CLASSDESC: case TC_PROXYCLASSDESC: return readClassDesc(unshared); case TC_STRING: case TC_LONGSTRING://checkResovle方法 return checkResolve(readString(unshared)); case TC_ARRAY: return checkResolve(readArray(unshared)); case TC_ENUM: return checkResolve(readEnum(unshared)); case TC_OBJECT: return checkResolve(readOrdinaryObject(unshared)); case TC_EXCEPTION: IOException ex = readFatalException(); throw new WriteAbortedException("writing aborted", ex); case TC_BLOCKDATA: case TC_BLOCKDATALONG: if (oldMode) { bin.setBlockDataMode(true); bin.peek(); // force header read throw new OptionalDataException( bin.currentBlockRemaining()); } else { throw new StreamCorruptedException( "unexpected block data"); } case TC_ENDBLOCKDATA: if (oldMode) { throw new OptionalDataException(true); } else { throw new StreamCorruptedException( "unexpected end of block data"); } default: throw new StreamCorruptedException( String.format("invalid type code: %02X", tc)); } } finally { depth--; bin.setBlockDataMode(oldMode); } } private Object readOrdinaryObject(boolean unshared) throws IOException { if (bin.readByte() != TC_OBJECT) { throw new InternalError(); } ObjectStreamClass desc = readClassDesc(false); desc.checkDeserialize(); Class<?> cl = desc.forClass(); if (cl == String.class || cl == Class.class || cl == ObjectStreamClass.class) { throw new InvalidClassException("invalid class descriptor"); } Object obj; try { obj = desc.isInstantiable() ? desc.newInstance() : null; } catch (Exception ex) { throw (IOException) new InvalidClassException( desc.forClass().getName(), "unable to create instance").initCause(ex); } passHandle = handles.assign(unshared ? unsharedMarker : obj); ClassNotFoundException resolveEx = desc.getResolveException(); if (resolveEx != null) { handles.markException(passHandle, resolveEx); } if (desc.isExternalizable()) { readExternalData((Externalizable) obj, desc); } else { readSerialData(obj, desc); } handles.finish(passHandle); if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) { Object rep = desc.invokeReadResolve(obj);//核心逻辑 if (unshared && rep.getClass().isArray()) { rep = cloneArray(rep); } if (rep != obj) { // Filter the replacement object if (rep != null) { if (rep.getClass().isArray()) { filterCheck(rep.getClass(), Array.getLength(rep)); } else { filterCheck(rep.getClass(), -1); } } handles.setObject(passHandle, obj = rep); } } return obj; } Object invokeReadResolve(Object obj) throws IOException, UnsupportedOperationException { requireInitialized(); if (readResolveMethod != null) { try {//如果有readResolve方法，就会调用readResolve的结果 return readResolveMethod.invoke(obj, (Object[]) null); } catch (InvocationTargetException ex) { Throwable th = ex.getTargetException(); if (th instanceof ObjectStreamException) { throw (ObjectStreamException) th; } else { throwMiscException(th); throw new InternalError(th); // never reached } } catch (IllegalAccessException ex) { // should not occur, as access checks have been suppressed throw new InternalError(ex); } } else { throw new UnsupportedOperationException(); } }
当不存在readResolve方法时，就会执行newInstance方法，创建实例，导致单例被坏
4.ThreadLocal单例
ThreadLocal线程局部，创建一个与线程绑定的变量，所以，它能隔离线程。
它天生能保证线程安全。
4.1.示例代码
package com.wf.singleton.threadlocal; /** * @ClassName ThreadLocalSingleton * @Description TODO * @Author wf * @Date 2020/5/6 12:18 * @Version 1.0 */ public class ThreadLocalSingleton { private static final ThreadLocal<ThreadLocalSingleton> theadLocalInstance = new ThreadLocal<ThreadLocalSingleton>(){ @Override protected ThreadLocalSingleton initialValue() { return new ThreadLocalSingleton(); } }; private ThreadLocalSingleton(){} public static ThreadLocalSingleton getInstance(){ return theadLocalInstance.get(); } }
测试代码：
package com.wf.singleton; import com.wf.singleton.threadlocal.ThreadLocalSingleton; /** * @ClassName ThreadLocalSingletonTest * @Description TODO * @Author wf * @Date 2020/5/6 12:24 * @Version 1.0 */ public class ThreadLocalSingletonTest { public static void main(String[] args) { System.out.println(ThreadLocalSingleton.getInstance()); System.out.println(ThreadLocalSingleton.getInstance()); System.out.println(ThreadLocalSingleton.getInstance()); } }
测试结果如下：
多次获取实例，得到同一实例。显然是满足单例的。
但是,ThreadLocal有其特殊性，它是线程绑定的。即不同线程获得实例，可能是不同的。
4.1.1.ThreadLocal单例特殊性测试
package com.wf.singleton; import com.wf.singleton.threadlocal.ThreadLocalSingleton; /** * @ClassName ThreadLocalSingletonTest * @Description TODO * @Author wf * @Date 2020/5/6 12:24 * @Version 1.0 */ public class ThreadLocalSingletonTest { public static void main(String[] args) { System.out.println(ThreadLocalSingleton.getInstance()); System.out.println(ThreadLocalSingleton.getInstance()); System.out.println(ThreadLocalSingleton.getInstance()); Thread t1 = new Thread(()->{ System.out.println(Thread.currentThread().getName()+":"+ThreadLocalSingleton.getInstance()); }); Thread t2 = new Thread(() ->{ System.out.println(Thread.currentThread().getName()+":"+ThreadLocalSingleton.getInstance()); }); t1.start(); t2.start(); System.out.println("end"); } }
测试结果如下：
说明：
似乎是产生了三个不同的实例。似乎是破坏了单例。但这是正常的。
ThreadLocal只能保证同一线程下，只有一个实例。
所以，这种单例是一种局限性单例。有其特殊的应用场景。
4.2.ThreadLocal的原理探究
核心方法：get()
public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t);//获取map if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this);//key是this,表示当前对象所在线程 if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); }
线程的原因，是内部存在一个map维护数据，key是当前对象的所在的线程。
5.单例在源码中应用
spring中AbstractFactoryBean#getObject
Mybatis中ErrorContext[ThreadLocal的应用]
6.单例模式的总结
6.1.优点
在内存中只有一个实例，减少了内存开销。
可以避免对资源的多重占用。
设置全局访问点，严格控制访问。
6.2.缺点
不能面向接口编程。扩展困难。
如果要扩展单例对象，只能修改代码。【某种意义上说，违背开闭原则】
6.3.相关知识点总结
1.构造器私有
2.保证线程安全性
3.延迟加载【懒汉式--使用才创建】
4.防止序列化和反序列化破坏单例
5.防御反射破坏单例
6.4.补充知识---容器式单例的线程安全性解决
AbstractBeanFactory----getBean--->doGetBean--->getObjectForBeanInstance--->getObjectFromFactoryBean
可以知道，使用synchronized同步锁
附录：
idea自动生成junit测试类：
两种快捷键：
1.在要生成测试类的类里面，按ctrl+shift+t –> create new test
浙公网安备 33010602011771号