Merge pull request crossoverJie#3 from crossoverJie/fix

crossoverJie · web-flow · commit 7ef1929f55a0 · 2018-03-07T15:01:38.000+08:00
new features:
wait notify mechanism
diff --git a/MD/Threadcore.md b/MD/Threadcore.md
@@ -1,7 +1,7 @@
 # Java 多线程三大核心
 
 ## 原子性
-Java 的原子性就和数据库事物的原子性差不多，一个操作中要么全部执行成功或者失败。
+`Java` 的原子性就和数据库事物的原子性差不多，一个操作中要么全部执行成功或者失败。
 
 `JMM` 只是保证了基本的原子性，但类似于 `i++` 之类的操作，看似是原子操作，其实里面涉及到:
 
@@ -11,7 +11,7 @@ Java 的原子性就和数据库事物的原子性差不多，一个操作中要
 
 这三步操作，所以想要实现 `i++` 这样的原子操作就需要用到 `synchronize` 或者是 `lock` 进行加锁处理。
 
-如果是基础类的自增操作可以使用 `AtomicInteger` 这样的原子类来实现(其本质是利用了 CPU 级别的 的 `CAS` 指令来完成的)。
+如果是基础类的自增操作可以使用 `AtomicInteger` 这样的原子类来实现(其本质是利用了 `CPU` 级别的 的 `CAS` 指令来完成的)。
 
 其中用的最多的方法就是: `incrementAndGet()` 以原子的方式自增。
 源码如下:
@@ -46,7 +46,7 @@ public final boolean compareAndSet(long expect, long update) {
 
 ## 可见性
 
-现代计算机中，由于 `CPU` 直接从主内存中读取数据的效率不高，所以都会对应的 CPU 高速缓存，先将主内存中的数据读取到缓存中，线程修改数据之后首先更新到缓存，之后才会更新到主内存。如果此时还没有将数据更新到主内存其他的线程此时来读取就是修改之前的数据。
+现代计算机中，由于 `CPU` 直接从主内存中读取数据的效率不高，所以都会对应的 `CPU` 高速缓存，先将主内存中的数据读取到缓存中，线程修改数据之后首先更新到缓存，之后才会更新到主内存。如果此时还没有将数据更新到主内存其他的线程此时来读取就是修改之前的数据。
 
 ![](https://ws2.sinaimg.cn/large/006tKfTcly1fmouu3fpokj31ae0osjt1.jpg)
 
@@ -81,7 +81,7 @@ Java 中可以使用 `volatile` 来保证顺序性，`synchronize 和 lock` 也
 
 #### 双重检查锁的单例模式
 
-可以用 volatile 实现一个双重检查锁的单例模式：
+可以用 `volatile` 实现一个双重检查锁的单例模式：
 
 ```java
 public class Singleton{
@@ -101,14 +101,14 @@ public class Singleton{
 }
 ```
 
-这里的 volatile 关键字主要是为了防止指令重排。
-如果不用 volatile ，`singleton = new Singleton();`，这段代码其实是分为三步：
+这里的 `volatile` 关键字主要是为了防止指令重排。
+如果不用 `volatile` ，`singleton = new Singleton();`，这段代码其实是分为三步：
 
 - 分配内存空间。(1)
 - 初始化对象。(2)
 - 将 `singleton` 对象指向分配的内存地址。(3)
 
-加上 volatile 是为了让以上的三步操作顺序执行，反之有可能第二步在第三步之前被执行就有可能某个线程拿到的单例对象是还没有初始化的，以致于报错。
+加上 `volatile` 是为了让以上的三步操作顺序执行，反之有可能第二步在第三步之前被执行就有可能某个线程拿到的单例对象是还没有初始化的，以致于报错。
 
 #### 控制停止线程的标记
 
@@ -132,7 +132,7 @@ private void stop(){
 这里主要利用的是 `volatile` 的内存可见性。
 
 总结一下:
-- volatile 关键字只能保证可见性，顺序性，**不能保证原子性**。
+- `volatile` 关键字只能保证可见性，顺序性，**不能保证原子性**。
 
 
 
diff --git a/src/main/java/com/crossoverjie/actual/TwoThread.java b/src/main/java/com/crossoverjie/actual/TwoThread.java
@@ -6,6 +6,8 @@
 /**
  * Function: 两个线程交替执行打印 1~100
  *
+ * lock 版
+ *
  * @author crossoverJie
  *         Date: 11/02/2018 10:04
  * @since JDK 1.8
diff --git a/src/main/java/com/crossoverjie/actual/TwoThreadWaitNotify.java b/src/main/java/com/crossoverjie/actual/TwoThreadWaitNotify.java
@@ -0,0 +1,101 @@
+package com.crossoverjie.actual;
+
+/**
+ * Function:两个线程交替执行打印 1~100
+ * 等待通知机制版
+ *
+ * @author crossoverJie
+ *         Date: 07/03/2018 13:19
+ * @since JDK 1.8
+ */
+public class TwoThreadWaitNotify {
+
+    private int start = 1;
+
+    private boolean flag = false;
+
+    public static void main(String[] args) {
+        TwoThreadWaitNotify twoThread = new TwoThreadWaitNotify();
+
+        Thread t1 = new Thread(new OuNum(twoThread));
+        t1.setName("t1");
+
+
+        Thread t2 = new Thread(new JiNum(twoThread));
+        t2.setName("t2");
+
+        t1.start();
+        t2.start();
+    }
+
+    /**
+     * 偶数线程
+     */
+    public static class OuNum implements Runnable {
+        private TwoThreadWaitNotify number;
+
+        public OuNum(TwoThreadWaitNotify number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+
+            while (number.start <= 100) {
+                synchronized (TwoThreadWaitNotify.class) {
+                    System.out.println("偶数线程抢到锁了");
+                    if (number.flag) {
+                        System.out.println(Thread.currentThread().getName() + "+-+偶数" + number.start);
+                        number.start++;
+
+                        number.flag = false;
+                        TwoThreadWaitNotify.class.notify();
+
+                    }else {
+                        try {
+                            TwoThreadWaitNotify.class.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+
+            }
+        }
+    }
+
+
+    /**
+     * 奇数线程
+     */
+    public static class JiNum implements Runnable {
+        private TwoThreadWaitNotify number;
+
+        public JiNum(TwoThreadWaitNotify number) {
+            this.number = number;
+        }
+
+        @Override
+        public void run() {
+            while (number.start <= 100) {
+                synchronized (TwoThreadWaitNotify.class) {
+                    System.out.println("奇数线程抢到锁了");
+                    if (!number.flag) {
+                        System.out.println(Thread.currentThread().getName() + "+-+奇数" + number.start);
+                        number.start++;
+
+                        number.flag = true;
+
+                        TwoThreadWaitNotify.class.notify();
+                    }else {
+                        try {
+                            TwoThreadWaitNotify.class.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@`
`6`	`6`	`/**`
`7`	`7`	`* Function: 两个线程交替执行打印 1~100`
`8`	`8`	`*`
	`9`	`+ * lock 版`
	`10`	`+ *`
`9`	`11`	`* @author crossoverJie`
`10`	`12`	`* Date: 11/02/2018 10:04`
`11`	`13`	`* @since JDK 1.8`