diff --git a/notes/设计模式  - 单例.md b/notes/设计模式  - 单例.md
index b0f62035..0b449479 100644
--- a/notes/设计模式  - 单例.md	
+++ b/notes/设计模式  - 单例.md	
@@ -11,7 +11,7 @@
 <div align="center"> <img src="pics/dp-singleton.png" width="760px"/> </div><br>
 
 ### 实现
-#### Ⅰ 懒汉式-线程不安全
+#### 1. 懒汉式-线程不安全
 
 以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
 
@@ -34,7 +34,7 @@ public class Singleton {
 }
 ```
 
-#### Ⅱ 饿汉式-线程安全
+#### 2. 饿汉式-线程安全
 
 线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。
 
@@ -44,7 +44,7 @@ public class Singleton {
 private static Singleton uniqueInstance = new Singleton();
 ```
 
-#### Ⅲ 懒汉式-线程安全
+#### 3. 懒汉式-线程安全
 
 只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。
 
@@ -59,7 +59,7 @@ public static synchronized Singleton getUniqueInstance() {
 }
 ```
 
-#### Ⅳ 双重校验锁-线程安全
+#### 4. 双重校验锁-线程安全
 
 uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
 
@@ -98,15 +98,15 @@ if (uniqueInstance == null) {
 
 uniqueInstance 采用 volatile 关键字修饰也是很有必要的， `uniqueInstance = new Singleton();` 这段代码其实是分为三步执行：
 
-1. 为 uniqueInstance 分配内存空间
-2. 初始化 uniqueInstance
+1. 为对象分配内存空间
+2. 初始化对象
 3. 将 uniqueInstance 指向分配的内存地址
 
 但是由于 JVM 具有重排序的特性，执行顺序有可能变成 1>3>2。重排序在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
 
 使用 volatile 可以禁止 JVM 的重排序，保证在多线程环境下也能正常运行。
 
-#### Ⅴ 静态内部类实现
+#### 5. 静态内部类实现
 
 当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
 
@@ -128,9 +128,11 @@ public class Singleton {
 }
 ```
 
-#### Ⅵ 枚举实现
+#### 6. 枚举实现
 
 ```java
+import java.lang.reflect.Constructor;
+
 public enum Singleton {
 
     INSTANCE;
@@ -159,14 +161,13 @@ public enum Singleton {
         System.out.println(firstSingleton.getObjName());
         System.out.println(secondSingleton.getObjName());
 
-        // 反射获取实例测试
+        // 通过反射调用构造函数创建新的实例会失败
         try {
-            Singleton[] enumConstants = Singleton.class.getEnumConstants();
-            for (Singleton enumConstant : enumConstants) {
-                System.out.println(enumConstant.getObjName());
-            }
+            Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor(String.class, int.class);
+            constructor.setAccessible(true);
+            constructor.newInstance("INSTANCE2", 1);
         } catch (Exception e) {
-            e.printStackTrace();
+            System.out.println(e);
         }
     }
 }
@@ -176,7 +177,7 @@ public enum Singleton {
 firstName
 secondName
 secondName
-secondName
+java.lang.IllegalArgumentException: Cannot reflectively create enum objects
 ```
 
 该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。
@@ -192,7 +193,7 @@ secondName
 ### JDK 中的应用
 - [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
 - [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
-- [java.lang.System#getSecurityManager()](https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
+- [java.lang.System#getSecurityManager()](https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)（JDK 17 起已废弃，JEP 411）
 
 ## 参考资料