funnycoding
diff --git a/‎java_concurrency_in_practice/docs/2/2.线程安全性(总).md
Lines changed: 16 additions & 2 deletions b/‎java_concurrency_in_practice/docs/2/2.线程安全性(总).md
Lines changed: 16 additions & 2 deletions
diff --git a/‎java_concurrency_in_practice/src/main/java/chapter1/NonSafeSequence.java
Lines changed: 23 additions & 0 deletions b/‎java_concurrency_in_practice/src/main/java/chapter1/NonSafeSequence.java
Lines changed: 23 additions & 0 deletions
diff --git a/‎java_concurrency_in_practice/src/main/java/chapter1/SafeSequence.java
Lines changed: 4 additions & 1 deletion b/‎java_concurrency_in_practice/src/main/java/chapter1/SafeSequence.java
Lines changed: 4 additions & 1 deletion
diff --git a/‎java_concurrency_in_practice/src/test/java/chapger1/Chapter1Test.java
Lines changed: 52 additions & 0 deletions b/‎java_concurrency_in_practice/src/test/java/chapger1/Chapter1Test.java
Lines changed: 52 additions & 0 deletions
diff --git a/‎java_concurrency_in_practice/src/test/java/chapger1/UnsafeCountingFactorizerTest.java
Lines changed: 7 additions & 1 deletion b/‎java_concurrency_in_practice/src/test/java/chapger1/UnsafeCountingFactorizerTest.java
Lines changed: 7 additions & 1 deletion
@@ -173,8 +173,6 @@ public class UnsafeCachingFactorizer implements Servlet {
 
 
 
-
-
 ### 活跃性与性能
 
 锁的引入保证了线程安全性，但是同时也带来了活跃性与性能问题。如果没有分析好作用域而滥用锁的话，会导致程序非常严重的串行化，从而导致性能下降。
@@ -191,6 +189,22 @@ public class UnsafeCachingFactorizer implements Servlet {
 
 
 
+
+
+### 总结
+
+第一遍看的时候真是感觉信息量好大，这学了一圈再加上三刷、四刷之后发现不断压缩本章的核心内容的话，压缩之后的话这一章的内容也就还好，更多的也是偏概念上的，还没有真正开始深入讲 Java 中对应的实现，或者只是提了个概念。
+
+同时我对**极客时间的《Java 并发编程实战》**这门课的内容的**感官也在不断的变化**。
+
+最开始只是觉得是这本书的下位替代，但是现在觉得也并不尽然。
+
+其中包含了很多易懂的示例图，给出的代码也比书中仅是片段的要好一些，最重要的是深挖到了比较通用的并发编程解决范式比如管程模型 & 信号量，再到管程中的几个模型具体的介绍，哪怕只是个引子，也能让你明白该往什么方向去探究。
+
+总的来说还是挺有价值的。
+
+
+
 ### 脑图：
 
 <p align="center">
 
@@ -0,0 +1,23 @@
+package chapter1;
+
+/**
+ * @author XuYanXin
+ * @program java_learning
+ * @description
+ * @date 2020/9/26 11:29 下午
+ */
+
+public class NonSafeSequence {
+    private int value;
+
+    public  void addValue() throws InterruptedException {
+        System.out.println("Thread:" + Thread.currentThread().getName()+"," + "value add 之前的值：" + value);
+        value++;
+        Thread.sleep(500);
+        System.out.println("Thread:" + Thread.currentThread().getName()+"," + "value add 之后的值：" + value);
+    }
+
+    pu
8000
blic int getValue() {
+        return value;
+    }
+}
@@ -13,8 +13,11 @@ public class SafeSequence {
     /**
      * 使用 synchronized Java的内置同步原语 —— 锁 就可以保证同一时间只有1个线程进入这个方法
      */
-    public synchronized void addValue() {
+    public synchronized void addValue() throws InterruptedException {
+        System.out.println("Thread:" + Thread.currentThread().getName()+"," + "value add 之前的值：" + value);
         value++;
+        Thread.sleep(500);
+        System.out.println("Thread:" + Thread.currentThread().getName()+"," + "value add 之后的值：" + value);
     }
 
     public int getValue() {
 
@@ -0,0 +1,52 @@
+package chapger1;
+
+import chapter1.NonSafeSequence;
+import chapter1.SafeSequence;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author XuYanXin
+ * @program java_learning
+ * @description
+ * @date 2020/9/26 11:29 下午
+ */
+
+public class Chapter1Test {
+    @Test
+    public void testUnsafeSequence() throws InterruptedException {
+        NonSafeSequence nonSafeSequence = new NonSafeSequence();
+
+        for (int i = 0; i < 10; i++) {
+            Thread thread = new Thread(() -> {
+                try {
+                    nonSafeSequence.addValue();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            });
+            thread.start();
+        }
+
+        Assert.assertEquals(10, nonSafeSequence.getValue());
+    }
+
+
+    @Test
+    public void testSafeSequence() throws InterruptedException {
+        SafeSequence ss = new SafeSequence();
+
+        for (int i = 0; i < 10; i++) {
+            Thread thread = new Thread(() -> {
+                try {
+                    ss.addValue();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            });
+            thread.start();
+            thread.join();
+        }
+        Assert.assertEquals(10, ss.getValue());
+    }
+}
@@ -35,7 +35,13 @@ public void testSafeSequence() throws InterruptedException {
         SafeSequence ss = new SafeSequence();
 
         for (int i = 0; i < 10; i++) {
-            Thread thread = new Thread(ss::addValue);
+            Thread thread = new Thread(() -> {
+                try {
+                    ss.addValue();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            });
             thread.start();
             thread.join();
         }