update

vcao-aspira · vcao-aspira · commit bb98a20442af · 2021-02-05T16:25:02.000+08:00
diff --git a/03concurrency/0301/pom.xml b/03concurrency/0301/pom.xml
@@ -19,6 +19,14 @@
             </plugin>
         </plugins>
     </build>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.11</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl1.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl1.java
@@ -1,25 +1,24 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-
 /**
- * 应用Future机制
+ * 应用 volatile 机制
  */
-public class AsyncResultImpl1 implements AsyncResult{
+public class AsyncResultImpl1 implements AsyncResult {
+    private volatile int result = -1;
+    private volatile boolean hadComputed = false;
     @Override
-    public int getResult() throws Exception{
-        ExecutorService executorService = Executors.newFixedThreadPool(1);
-        Future<Integer> future = executorService.submit(new Callable<Integer>() {
+    public int getResult() throws Exception {
+        new Thread(new Runnable() {
             @Override
-            public Integer call() {
-                return sum();
+            public void run() {
+                result = sum();
+                hadComputed = true;
             }
-        });
-        // 注意关闭线程池，否则main线程不会结束，会一直等待，直到线程池被关闭。
-        executorService.shutdown();
-        return future.get();
+        }).start();
+
+        while (!hadComputed){
+            Thread.yield();// 防止一直占用线程
+        }
+        return result;
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl10.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl10.java
@@ -1,34 +1,22 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
 
+/**
+ * 应用阻塞队列
+ */
 public class AsyncResultImpl10 implements AsyncResult {
-    private volatile int result = -1;
-
+    private BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(1);
     @Override
     public int getResult() throws Exception {
-        final ReentrantLock lock = new ReentrantLock(false);
-        Condition hadCompute = lock.newCondition();
         new Thread(new Runnable() {
             @Override
             public void run() {
-                lock.lock();
-                try {
-                    result = sum();
-                    hadCompute.signalAll();
-                }finally {
-                    lock.unlock();
-                }
+                blockingQueue.offer(sum());
             }
         }).start();
 
-        lock.lock();
-        try {
-            hadCompute.await();
-            return result;
-        }finally {
-            lock.unlock();
-        }
+        return blockingQueue.take();
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl2.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl2.java
@@ -1,20 +1,29 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * 应用CAS机制
+ */
+public class AsyncResultImpl2 implements AsyncResult {
 
-public class AsyncResultImpl2 implements AsyncResult{
     private volatile int result = -1;
+
+    private AtomicInteger tag = new AtomicInteger(1);
+
     @Override
     public int getResult() throws Exception {
-        CountDownLatch countDownLatch = new CountDownLatch(1);
         new Thread(new Runnable() {
             @Override
             public void run() {
                 result = sum();
-                countDownLatch.countDown();
+                tag.getAndDecrement();
             }
         }).start();
-        countDownLatch.await();
+
+        while (tag.get() > 0){
+            Thread.yield();
+        }
         return result;
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl3.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl3.java
@@ -1,27 +1,21 @@
 package java0.conc0303.homework;
 
 /**
- * 应用传统的synchronized锁通知机制
+ * 应用join 机制
  */
 public class AsyncResultImpl3 implements AsyncResult {
     private volatile int result = -1;
-    private final Object getResultLock = new Object();
-
     @Override
     public int getResult() throws Exception {
-        new Thread(new Runnable() {
+        Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
-                synchronized (getResultLock) {
-                    result = sum();
-                    getResultLock.notifyAll();
-                }
+                result = sum();
             }
-        }).start();
+        });
+        t1.start();
+        t1.join();
 
-        synchronized (getResultLock) {
-            getResultLock.wait();
-            return result;
-        }
+        return result;
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl4.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl4.java
@@ -1,22 +1,27 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-
 /**
- * 应用阻塞队列
+ * 应用传统的synchronized锁通知机制
  */
 public class AsyncResultImpl4 implements AsyncResult {
-    private BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(1);
+    private volatile int result = -1;
+    private final Object getResultLock = new Object();
+
     @Override
     public int getResult() throws Exception {
         new Thread(new Runnable() {
             @Override
             public void run() {
-                blockingQueue.offer(sum());
+                synchronized (getResultLock) {
+                    result = sum();
+                    getResultLock.notifyAll();
+                }
             }
         }).start();
 
-        return blockingQueue.take();
+        synchronized (getResultLock) {
+            getResultLock.wait();
+            return result;
+        }
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl5.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl5.java
@@ -1,29 +1,34 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.Semaphore;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
 
-/**
- * 应用Semaphore机制
- */
 public class AsyncResultImpl5 implements AsyncResult {
     private volatile int result = -1;
 
     @Override
     public int getResult() throws Exception {
-        final Semaphore semaphore = new Semaphore(2);
-        semaphore.acquire(1);
+        final ReentrantLock lock = new ReentrantLock(false);
+        Condition hadCompute = lock.newCondition();
         new Thread(new Runnable() {
             @Override
             public void run() {
+                lock.lock();
                 try {
                     result = sum();
+                    hadCompute.signalAll();
                 }finally {
-                    semaphore.release(1);
+                    lock.unlock();
                 }
             }
         }).start();
 
-        semaphore.acquire(2);
-        return result;
+        lock.lock();
+        try {
+            hadCompute.await();
+            return result;
+        }finally {
+            lock.unlock();
+        }
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl6.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl6.java
@@ -1,27 +1,23 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.CountDownLatch;
 
 /**
- * 应用 CyclicBarrier 机制
+ * 应用CountDownLatch机制
  */
-public class AsyncResultImpl6 implements AsyncResult {
+public class AsyncResultImpl6 implements AsyncResult{
     private volatile int result = -1;
     @Override
     public int getResult() throws Exception {
-        final CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
+        CountDownLatch countDownLatch = new CountDownLatch(1);
         new Thread(new Runnable() {
             @Override
             public void run() {
-                try {
-                    result = sum();
-                    cyclicBarrier.await();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
+                result = sum();
+                countDownLatch.countDown();
             }
         }).start();
-        cyclicBarrier.await();
+        countDownLatch.await();
         return result;
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl7.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl7.java
@@ -1,29 +1,27 @@
 package java0.conc0303.homework;
 
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.CyclicBarrier;
 
 /**
- * 应用CAS机制
+ * 应用 CyclicBarrier 机制
  */
 public class AsyncResultImpl7 implements AsyncResult {
-
     private volatile int result = -1;
-
-    private AtomicInteger tag = new AtomicInteger(1);
-
     @Override
     public int getResult() throws Exception {
+        final CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
         new Thread(new Runnable() {
             @Override
             public void run() {
-                result = sum();
-                tag.getAndDecrement();
+                try {
+                    result = sum();
+                    cyclicBarrier.await();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
             }
         }).start();
-
-        while (tag.get() > 0){
-            Thread.yield();
-        }
+        cyclicBarrier.await();
         return result;
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl8.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl8.java
@@ -1,24 +1,29 @@
 package java0.conc0303.homework;
 
+import java.util.concurrent.Semaphore;
+
 /**
- * 应用 volatile 机制
+ * 应用Semaphore机制
  */
 public class AsyncResultImpl8 implements AsyncResult {
     private volatile int result = -1;
-    private volatile boolean hadComputed = false;
+
     @Override
     public int getResult() throws Exception {
+        final Semaphore semaphore = new Semaphore(2);
+        semaphore.acquire(1);
         new Thread(new Runnable() {
             @Override
             public void run() {
-                result = sum();
-                hadComputed = true;
+                try {
+                    result = sum();
+                }finally {
+                    semaphore.release(1);
+                }
             }
         }).start();
 
-        while (!hadComputed){
-            Thread.yield();// 防止一直占用线程
-        }
+        semaphore.acquire(2);
         return result;
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl9.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/AsyncResultImpl9.java
@@ -1,21 +1,25 @@
 package java0.conc0303.homework;
 
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
 /**
- * 应用join 机制
+ * 应用Future机制
  */
-public class AsyncResultImpl9 implements AsyncResult {
-    private volatile int result = -1;
+public class AsyncResultImpl9 implements AsyncResult{
     @Override
-    public int getResult() throws Exception {
-        Thread t1 = new Thread(new Runnable() {
+    public int getResult() throws Exception{
+        ExecutorService executorService = Executors.newFixedThreadPool(1);
+        Future<Integer> future = executorService.submit(new Callable<Integer>() {
             @Override
-            public void run() {
-                result = sum();
+            public Integer call() {
+                return sum();
             }
         });
-        t1.start();
-        t1.join();
-
-        return result;
+        // 注意关闭线程池，否则main线程不会结束，会一直等待，直到线程池被关闭。
+        executorService.shutdown();
+        return future.get();
     }
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/Homework.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/Homework.java
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/homework/Homework03.java b/03concurrency/0301/src/main/java/java0/conc0303/homework/Homework03.java
