concurrent test

whatsmars-common/src/test/java/org/hongxi/java/util/concurrent/CompletionServiceTest.java

+package org.hongxi.java.util.concurrent;
+
+import java.util.Random;
+import java.util.concurrent.*;
+
+/**
+ * @author shenhongxi 2019/8/11
+ */
+public class CompletionServiceTest {
+
+    public static void main(String[] args) {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+        CompletionService<Integer> completionService = new ExecutorCompletionService<>(executor);
+        for (int i = 1; i <= 10; i++) {
+            final int seq = i;
+            completionService.submit(() -> {
+                Thread.sleep(new Random().nextInt(5000));
+                return seq;
+            });
+        }
+        for (int i = 0; i < 10; i++) {
+            try {
+                System.out.println(completionService.take().get());
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } catch (ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+        executor.shutdown();
+    }
+}

whatsmars-common/src/test/java/org/hongxi/java/util/concurrent/CyclicBarrierTest.java

+package org.hongxi.java.util.concurrent;
+
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class CyclicBarrierTest {
+
+    public static void main(String[] args) {
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        final CyclicBarrier cb = new CyclicBarrier(3);
+        for (int i = 0; i < 3; i++) {
+            executorService.execute(() -> {
+                try {
+                    Thread.sleep((long) (Math.random() * 10000));
+                    System.out.println("线程"
+                            + Thread.currentThread().getName()
+                            + "即将到达集合地点1，当前已有"
+                            + (cb.getNumberWaiting() + 1)
+                            + "个已经到达，"
+                            + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊"
+                            : "正在等候"));
+                    cb.await();
+
+                    Thread.sleep((long) (Math.random() * 10000));
+                    System.out.println("线程"
+                            + Thread.currentThread().getName()
+                            + "即将到达集合地点2，当前已有"
+                            + (cb.getNumberWaiting() + 1)
+                            + "个已经到达，"
+                            + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊"
+                            : "正在等候"));
+                    cb.await();
+                    Thread.sleep((long) (Math.random() * 10000));
+                    System.out.println("线程"
+                            + Thread.currentThread().getName()
+                            + "即将到达集合地点3，当前已有"
+                            + (cb.getNumberWaiting() + 1)
+                            + "个已经到达，"
+                            + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊"
+                            : "正在等候"));
+                    cb.await();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            });
+        }
+        executorService.shutdown();
+    }
+}
\ No newline at end of file

whatsmars-common/src/test/java/org/hongxi/java/util/concurrent/ExchangerTest.java

+package org.hongxi.java.util.concurrent;
+
+import java.util.concurrent.Exchanger;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class ExchangerTest {
+    public static void main(String[] args) {
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        final Exchanger<String> exchanger = new Exchanger<String>();
+        executorService.execute(() -> {
+            try {
+                String data1 = "zxx";
+                System.out.println("线程" + Thread.currentThread().getName()
+                        + "正在把数据" + data1 + "换出去");
+                Thread.sleep((long) (Math.random() * 10000));
+                String data2 = exchanger.exchange(data1);
+                System.out.println("线程" + Thread.currentThread().getName()
+                        + "换回的数据为" + data2);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+        executorService.execute(() -> {
+            try {
+                String data1 = "lhm";
+                System.out.println("线程" + Thread.currentThread().getName()
+                        + "正在把数据" + data1 + "换出去");
+                Thread.sleep((long) (Math.random() * 10000));
+                String data2 = exchanger.exchange(data1);
+                System.out.println("线程" + Thread.currentThread().getName()
+                        + "换回的数据为" + data2);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+    }
+}
\ No newline at end of file

whatsmars-common/src/test/java/org/hongxi/java/util/concurrent/SemaphoreTest.java

+package org.hongxi.java.util.concurrent;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Semaphore;
+
+/**
+ * @author shenhongxi 2019/8/11
+ */
+public class SemaphoreTest {
+    public static void main(String[] args) {
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        final Semaphore semaphore = new Semaphore(3);
+        for (int i = 0; i < 10; i++) {
+            executorService.execute(() -> {
+                try {
+                    semaphore.acquire();
+                } catch (InterruptedException e1) {
+                    e1.printStackTrace();
+                }
+                System.out.println("线程" + Thread.currentThread().getName() +
+                        "进入，当前已有" + (3 - semaphore.availablePermits()) + "个并发");
+                try {
+                    Thread.sleep((long) (Math.random() * 10000));
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                System.out.println("线程" + Thread.currentThread().getName() +
+                        "即将离开");
+                semaphore.release();
+                //下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
+                System.out.println("线程" + Thread.currentThread().getName() +
+                        "已离开，当前已有" + (3 - semaphore.availablePermits()) + "个并发");
+            });
+        }
+    }
+}