Update

Author: CodePrometheus

DeadLock/src/DeadLockSummary.java

@@ -9,7 +9,7 @@ public class DeadLockSummary {
     /**
      * 1.发生在并发中
      * 2.互不相让
-     * 3.如果多个线程之间的依赖关系是环形，存在环路的锁的依赖关系，也可能会发生死锁
+     * 3.如果多个线程11之间的依赖关系是环形，存在环路的锁的依赖关系，也可能会发生死锁
      */
 
 
@@ -24,7 +24,7 @@ public class DeadLockSummary {
 
     /**
      * 进餐问题的解决方案
-     *  -> 服务员见检查（避免策略）
+     *  -> 服务员检查（避免策略）
      *  -> 改变一个哲学家拿叉子的顺序（避免策略）
      *  -> 餐票（避免策略）
      *  -> 领导调节（检测与恢复策略）

JMM/src/singleton/hungryman/SingletonStaticCodeBlock.java

@@ -1,7 +1,7 @@
 package singleton.hungryman;
 
 /**
- * 单例实现之二 -> 饿汉式（静态代码块）
+ * 单例实现之二 -> 饿汉式（静态代码块） 可用
  *
  * @Author: zzStar
  * @Date: 10-20-2020 10:24

JMM/src/singleton/hungryman/SingletonStaticFinal.java

@@ -1,7 +1,7 @@
 package singleton.hungryman;
 
 /**
- * 单例实现之一 -> 饿汉式（静态常量）
+ * 单例实现之一 -> 饿汉式（静态常量）可用
  *
  * @Author: zzStar
  * @Date: 10-20-2020 10:20
@@ -15,6 +15,7 @@ public static SingletonStaticFinal getINSTANCE() {
         return INSTANCE;
     }
 
+    // 单例模式的构造函数都是private
     private SingletonStaticFinal() {
     }
 

JMM/src/singleton/lazyman/SingletonDoubleCheck.java

@@ -19,7 +19,7 @@ public static SingletonDoubleCheck getInstance() {
 
         if (instance == null) {
             synchronized (SingletonDoubleCheck.class) {
-                // 第二个线程进来做一个判断检查
+                // 第二个线程进来做一个判断检查，依然是空，才创建实例
                 if (instance == null) {
                     instance = new SingletonDoubleCheck();
                 }

JMM/src/singleton/lazyman/SingletonStaticInnerClass.java

@@ -9,7 +9,6 @@
 public class SingletonStaticInnerClass {
 
     private SingletonStaticInnerClass() {
-
     }
 
     public static SingletonStaticInnerClass getInstance() {

JMM/src/singleton/lazyman/SingletonSynchronizationCodeBlock.java

@@ -1,7 +1,7 @@
 package singleton.lazyman;
 
 /**
- * 单例之五 -> 懒汉式（线程不安全，同步代码块）不可用
+ * 单例之五 -> 懒汉式（线程不安全，同步代码块）不可用，引申出双重检查
  *
  * @Author: zzStar
  * @Date: 10-20-2020 10:41

JMM/src/singleton/lazyman/SingletonSynchronizationMethod.java

@@ -13,6 +13,7 @@ public class SingletonSynchronizationMethod {
     private SingletonSynchronizationMethod() {
     }
 
+    // 区别于三，就是简单的在方法上加synchronized
     public synchronized static SingletonSynchronizationMethod getInstance() {
         // 适用于多线程环境
         if (instance == null) {

JMM/src/volatileusage/FieldVisibility.java

@@ -3,6 +3,11 @@
 /**
  * 演示可见性带来的问题（local cache 和 shared cache 的同步问题）
  * 第二个线程可能看不到前一个线程的操作，出现b=3,a=1
+ * <p>
+ * 普通三种情况
+ * a=3,b=2
+ * a=1,b=2
+ * a=3,b=2
  *
  * @Author: zzStar
  * @Date: 10-19-2020 17:07
@@ -16,6 +21,8 @@ public class FieldVisibility {
     // "近朱者赤" 实现了轻量级的同步
     // 作为刷新之前变量的触发器
     volatile int b = 2;
+    // 不加volatile会出现b=3,a=1
+    // int b = 2;
 
     private void change() {
         a = 3;

JMM/src/volatileusage/VolatileSummary.java

@@ -9,7 +9,7 @@
 public class VolatileSummary {
 
     /**
-     * Volatile是一种同步机制，比synchronized或者Lock相关类更轻量，因为使用Volatile并不会发生上下文切换等开销恒大的行为
+     * Volatile是一种同步机制，比synchronized或者Lock相关类更轻量，因为使用Volatile并不会发生上下文切换等开销很大的行为
      *    如果一个变量被修饰Volatile，JVM就知道这个变量可能被并发修改
      *    注意❗ Volatile做不到synchronized那样的原子保护，仅在很有限的场景下才能发挥作用
      */
@@ -46,4 +46,4 @@ public class VolatileSummary {
      * synchronized也具备近朱者赤
      *  -> synchronized不仅防止了一个线程在操作某对象时收到其他线程的干扰，同时还保证了修改好以后，可用立即被其他线程看到
      */
-}
+}