| 版本 | 内容 | 时间 | | ---- | ---- | --------------------- | | V1 | 新建 | 2021年7月29日23:25:05 | # 单例模式 [单例模式](#单例模式) - [单例模式的概念](#单例模式的概念) - [实现方式](#实现方式) - [饿汉式（静态常量）](#饿汉式静态常量) - [饿汉式（静态代码块）](#饿汉式静态代码块) - [懒汉式-线程不安全](#懒汉式-线程不安全) - [懒汉式-同步方法](#懒汉式-同步方法) - [懒加载-双重检查](#懒加载-双重检查) - [静态内部类](#静态内部类) - [CAS实现](#cas实现) - [枚举实现](#枚举实现) - [破坏单例以及修复](#破坏单例以及修复) - [反射破坏单例](#反射破坏单例) - [序列化破坏单例](#序列化破坏单例) - [克隆破坏单例](#克隆破坏单例) - [JDK中的单例模式](#jdk中的单例模式) - [单例模式的优缺点](#单例模式的优缺点) - [框架中的单例模式](#框架中的单例模式) - [Mybatis](#mybatis) - [Spring](#spring) ## 单例模式的概念 **定义：**保证一个类只有一个实例，自行实例化并提供一个全局访问点。 ## 实现方式 1) 饿汉式(静态常量) 2) 饿汉式（静态代码块） 3) 懒汉式(线程不安全) 4) 懒汉式(线程安全，同步方法) 5) 懒汉式(线程安全，同步代码块) 6) 双重检查 7) 静态内部类 8) 枚举 ### 饿汉式（静态常量）线程安全。 ```java public class Singleton01 { private static final Singleton01 INSTANCE = new Singleton01(); private Singleton01() { } public static Singleton01 getInstance() { return INSTANCE; } } ``` 优缺点说明优点：这种写法比较简单，就是在**类装载的时候就完成实例化。避免了线程同步问题**。缺点：在类装载的时候就完成实例化，**没有达到懒加载的效果**。如果从始至终都没有使用过这个实例，则会造成**内存的浪费**。 ### 饿汉式（静态代码块）线程安全。 ```java public class Singleton02 { private static final Singleton02 INSTANCE; static { try { INSTANCE = new Singleton02(); } catch (Exception e) { throw new RuntimeException("创建单例实例发生异常"); } } private Singleton02() { } public static Singleton02 getInstance() { return INSTANCE; } } ``` 初始化实现类似于上面那种，不同之处在于类的实例是在静态块中创建的，可以捕获异常。 ### 懒汉式-线程不安全线程不安全。 ```java public class Singleton03 { private static Singleton03 INSTANCE; private Singleton03() { } public static Singleton03 getInstance() { if (INSTANCE == null) { INSTANCE = new Singleton03(); } return INSTANCE; } } ``` 这个实现在单线程环境下能正常工作，但是在多线程下是有问题的，线程不安全。如果在多线程下，一个线程进入了`if(singleton == null)`判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这是便会产生多个实例。所以在多线程环境下不可使用这种方式。 ### 懒汉式-同步方法线程安全 ```java public class Singleton04 { private static Singleton04 INSTANCE; private Singleton04() { } /** * 同步方法 */ public static synchronized Singleton04 getInstance() { if (INSTANCE == null) { INSTANCE = new Singleton04(); } return INSTANCE; } } ``` 解决了线程不安全的问题。 **效率太低了，悲观锁**，每个线程在想获得类的实例的时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面想获得该类实例，直接return就行了。方法进行同步效率太低。 ### 懒加载-双重检查线程安全。 ```java public class Singleton06 { private static volatile Singleton06 INSTANCE; private Singleton06() { } public static Singleton06 getInstance() { if (INSTANCE == null) { synchronized (Singleton06.class) { if (INSTANCE == null) { INSTANCE = new Singleton06(); } } } return INSTANCE; } } ``` Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次`if(INSTANCE == null)`检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断`if(INSTANCE == null)`，直接return实例化对象，也避免的反复进行方法同步。优点：**线程安全、延迟加载、效率较高。** 注意INSTANCE字段需要使用volatile进行修饰，因为new一个对象并不是一个原子操作，**可能会发生指令重排**。创建一个对象的操作如下： 1、给对象分配内存。 2、调用构造方法初始化。 3、指向内存区域（这时就不为null了）。 **假如重排序后上面的步骤3跑到步骤2前面去了，当2执行完3还未执行时，其他线程进来就会返回未执行3的实例对象，从而导致空指针**。 ### 静态内部类线程安全。 ```java public class Singleton08 { private Singleton08() { } private static class SingletonHolder { private static final Singleton08 INSTANCE = new Singleton08(); } public static Singleton08 getInstance() { return SingletonHolder.INSTANCE; } } ``` 这种方式**采用了类加载的机制来保证初始化实例时只有一个线程**。静态内部类方式在Singleton类被加载时并不会立即实例化，而是在需要实例化时，调用getInstance方法才会装载SingletonInstance类，从而完成Singleton的实例化。 **类的静态属性只会在第一次加载类的时候初始化**，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。优点：**避免了线程不安全**，利用静态内部类特点时效内延迟加载，效率高。 ### CAS实现线程安全，但是有缺陷。后面解释 ```java public class Singleton07 { private static final AtomicReference INSTANCE = new AtomicReference<>(); private Singleton07() { } public static Singleton07 getInstance() { while (true) { Singleton07 singleton07 = INSTANCE.get(); if (null != singleton07) { return singleton07; } singleton07 = new Singleton07(); if (INSTANCE.compareAndSet(null, singleton07)) { return singleton07; } } } } ``` **CAS无锁实现单例，虽然能够保证最终返回的对象是同一个实例，但是在整个循环的过程中创建的对象可能不止一个。** 看一个测试类吧首先将原有的`Singleton07`的私有构造函数改造一下： ```java private Singleton07() { System.out.println(Thread.currentThread().getName() + " -> Singleton07 被初始化了"); CasSingletonTest.objectcount.getAndIncrement(); } ``` 测试类： ```java public class CasSingletonTest { public static AtomicInteger objectcount = new AtomicInteger(); private static final CountDownLatch begin = new CountDownLatch(1); private static final CountDownLatch last = new CountDownLatch(1000); public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 1000; i++) { new Thread(() -> { try { begin.await(); Singleton07 instance = Singleton07.getInstance(); last.countDown(); } catch (InterruptedException ex) { ex.printStackTrace(); } }).start(); } begin.countDown(); last.await(); System.out.println("创建对象的次数: " + objectcount.get()); } } ``` 控制台： ``` Thread-80 -> Singleton07 被初始化了 Thread-15 -> Singleton07 被初始化了 Thread-998 -> Singleton07 被初始化了 Thread-86 -> Singleton07 被初始化了 Thread-74 -> Singleton07 被初始化了 Thread-82 -> Singleton07 被初始化了 Thread-7 -> Singleton07 被初始化了 Thread-19 -> Singleton07 被初始化了 Thread-81 -> Singleton07 被初始化了 Thread-9 -> Singleton07 被初始化了 Thread-77 -> Singleton07 被初始化了创建对象的次数: 11 ``` **Q**：为什么会创建这么多个对象呢？ **A**：因为`compareAndSet`方法虽然使用CAS操作来给INSTANCE字段赋值，保证最终返回的INSTANCE是同一个实例。但是由于整个while循环内部的操作并不是原子性的，所以可能会有多个线程在判断` if (null != singleton07) `时返回false，此时这些个线程都会创建出一个Singleton07的对象，但是最终只有一个能成功赋值给INSTANCE。所以这种CAS实现单例的**缺点就是可能会创建多个对象出来**。 ### 枚举实现 ```java public enum Singleton09 { INSTANCE; } ``` 没错，就是这么简单。 - 这借助JDK1.5中添加的枚举来实现单例模式。**不仅能避免多线程同步问题，而且还能防止反序列化和反射重新创建新的对象**。 - 这种方式是Effective Java作者Josh Bloch 提倡的方式 **反编译看下枚举，可以看到INSTANCE是在静态代码块里面初始化的。** ```java public final class Singleton09 extends Enum { public static final Singleton09 INSTANCE; private static final Singleton09 $VALUES[]; public static Singleton09[] values() { return (Singleton09[])$VALUES.clone(); } public static Singleton09 valueOf(String name) { return (Singleton09)Enum.valueOf(cn/guosgbin/pattern/singleton/enumerate/Singleton09, name); } private Singleton09(String s, int i) { super(s, i); } static { INSTANCE = new Singleton09("INSTANCE", 0); $VALUES = (new Singleton09[] { INSTANCE }); } } ``` ## 破坏单例以及修复上面的除了枚举其他的方式都可能会被一些操作破坏单例，例如反射，序列化，克隆等。 ### 反射破坏单例 Singleton01是饿汉式，拿来测试。 ```java private static void RelectionTest() throws Exception { Singleton01 s1 = Singleton01.getInstance(); Constructor constructor = Singleton01.class.getDeclaredConstructor(); constructor.setAccessible(true); Singleton01 s2 = constructor.newInstance(); System.out.println("s1 == s2 ? " + (s1 == s2)); // false System.out.println("s1哈希值:" + s1.hashCode()); // 1163157884 System.out.println("s2哈希值:" + s2.hashCode()); // 1956725890 } ``` 可以看到两个对象并不是同一个实例，这就破坏了单例，**解决办法就是在构造函数中抛出异常**。 ```java private Singleton(){ if(INSTANCE != null){ throw new RuntimeException("重复创建单例对象"); } } ``` ### 序列化破坏单例 Singleton01是饿汉式，拿来测试。 **序列化单例类的问题在于，无论何时反序列化它，它都会创建该类的一个新实例。** ```java private static void SerializedTest() throws Exception { Singleton01 s1 = Singleton01.getInstance(); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/single")); oos.writeObject(s1); oos.close(); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/single")); Singleton01 s2 = (Singleton01) ois.readObject(); ois.close(); System.out.println("s1 == s2 ? " + (s1 == s2)); // false System.out.println("s1哈希值:" + s1.hashCode()); // 2133927002 System.out.println("s2哈希值:" + s2.hashCode()); // 1452126962 } ``` 通过结果看：这两个实例不是同一个，这就违背了单例设计模式的原则了。为了防止序列化破坏单例，可以在类中增加一个`readResolve()`方法的实现。 ```java private Object readResolve(){ return INSTANCE; } ``` `readResolve()`方法：如果一个类中定义了该方法，则对该类的对象进行反序列化操作后会调用该方法。最终这个方法返回的对象作为反序列化的结果。跟进反序列化源码有个`readOrdinaryObject()`方法。 ```java private Object readOrdinaryObject(boolean unshared) throws IOException { // 省略... 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); } // 省略... // 最后一个条件是判断类中有没有readResolve方法 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); } } // 将readResolve方法返回的值赋值给obj handles.setObject(passHandle, obj = rep); } } return obj; } ``` ### 克隆破坏单例让类实现Cloneable接口 ```java public static void main(String[] args) throws CloneNotSupportedException { CloneSingleton s1 = CloneSingleton.getInstance(); CloneSingleton s2 = (CloneSingleton) s1.clone(); System.out.println("s1 == s2 ? " + (s1 == s2)); // false System.out.println("s1哈希值:" + s1.hashCode()); // 2133927002 System.out.println("s2哈希值:" + s2.hashCode()); // 1452126962 } ``` 解决办法就是重写clone方法 ```java @Override protected Object clone() throws CloneNotSupportedException { return INSTANCE; } ``` ## JDK中的单例模式 Runtime类就是单例模式。 ```java public class Runtime { private static Runtime currentRuntime = new Runtime(); /** * Returns the runtime object associated with the current Java application. * Most of the methods of class Runtime are instance * methods and must be invoked with respect to the current runtime object. * * @return the Runtime object associated with the current * Java application. */ public static Runtime getRuntime() { return currentRuntime; } /** Don't let anyone else instantiate this class */ private Runtime() {} } ``` ## 单例模式的优缺点优点： - 你可以保证一个类只有一个实例，**减少了内存开销**。假如一个对象需要频繁地创建、销毁，且创建销毁的性能消耗比较大，此时使用单例模式就比较合适。 - 可以在系统中设置一个指向该实例的全局访问节点。缺点： - 单例模式的客户端代码单元测试会比较困难，因为许多测试框架基于继承的方式创建模拟对象。 ## 框架中的单例模式 ### Mybatis 在Mybatis中有个表示错误上下文的ErrorContext类，使用了单例模式。而且它的单例模式是绑定在ThreadLocal上的，保证了每个线程都有唯一的一个错误上下文ErrorContext。 ```java public class ErrorContext { // 获得当前操作系统的换行符 private static final String LINE_SEPARATOR = System.lineSeparator(); // 将自身存储进ThreadLocal，从而进行线程间的隔离 private static final ThreadLocal LOCAL = ThreadLocal.withInitial(ErrorContext::new); // 存储上一版本的自身，从而组成错误链 private ErrorContext stored; // 下面几条为错误的详细信息，可以写入一项或者多项 private String resource; private String activity; private String object; private String message; private String sql; private Throwable cause; private ErrorContext() { } /** * 从ThreadLocal取出已经实例化的ErrorContext * @return ErrorContext实例 */ public static ErrorContext instance() { return LOCAL.get(); } } ``` ### Spring TODO 后续补充

设计模式01-单例模式-Singleton.

Dylan Kwok

设计模式01-单例模式-Singleton