feat

Author: CodePrometheus

Interview/src/InTurnCommonBySemaphore.java

@@ -0,0 +1,34 @@
+import java.util.concurrent.Semaphore;
+
+/**
+ * @Author: zzStar
+ * @Date: 2021/9/9
+ * @Description: 通用解法：交替打印任意
+ */
+public class InTurnCommonBySemaphore {
+
+    // 规定的次数
+    private static final int times = 10;
+
+    // 需要打印任意就任意个信号量，但是第一个必须为1
+    static Semaphore a = new Semaphore(1);
+    static Semaphore b = new Semaphore(0);
+
+    public static void main(String[] args) {
+        new Thread(() -> print("a", a, b)).start();
+        new Thread(() -> print("b", b, a)).start();
+    }
+
+    private static void print(String name, Semaphore cur, Semaphore next) {
+        for (int i = 0; i < times; i++) {
+            try {
+                cur.acquire();
+                System.out.println(name);
+                next.release();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+}

Interview/src/print100Example01.java

@@ -0,0 +1,50 @@
+import java.util.concurrent.Semaphore;
+
+/**
+ * @Author: zzStar
+ * @Date: 2021/9/9
+ * @Description: N个线程顺序打印0-100，Semaphore
+ */
+public class print100Example01 {
+
+    // 定义N的值
+    private final static int n = 100;
+    static int result = 0;
+    static int maxNum = 100;
+
+    public static void main(String[] args) throws InterruptedException {
+        final Semaphore[] semaphores = new Semaphore[n];
+        for (int i = 0; i < n; i++) {
+            // 非公平信号量，每个信号量初始计数都为1
+            semaphores[i] = new Semaphore(1);
+            if (i != n - 1) {
+                // System.out.println(i + "===" + semaphores[i].getQueueLength());
+                // 获取一个许可前线程将一直阻塞, for 循环之后只有 semaphores[2] 没有被阻塞
+                semaphores[i].acquire();
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            // 初次执行，上一个信号量是 semaphores[2]
+            final Semaphore lastSemaphore = i == 0 ? semaphores[n - 1] : semaphores[i - 1];
+            final Semaphore currentSemaphore = semaphores[i];
+            final int index = i;
+            new Thread(() -> {
+                try {
+                    while (true) {
+                        // 初次执行，让第一个 for 循环没有阻塞的 semaphores[2] 先获得令牌阻塞了
+                        lastSemaphore.acquire();
+                        System.out.println("thread" + index + ": " + result++);
+                        if (result > maxNum) {
+                            System.exit(0);
+                        }
+                        // 释放当前的信号量，semaphores[0] 信号量此时为 1，下次 for semaphores[0]
+                        currentSemaphore.release();
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }).start();
+        }
+    }
+
+}

Interview/src/printABCExample01.java

@@ -0,0 +1,87 @@
+import java.util.concurrent.*;
+
+/**
+ * @Author: zzStar
+ * @Date: 2021/9/9
+ * @Description: 交叉打印ABC，Synchronized + wait/notify
+ */
+public class printABCExample01 {
+
+    private static int counter = 0;
+
+    private static final Object OBJ = new Object();
+
+    public static void main(String[] args) {
+
+        ExecutorService executorService = new ThreadPoolExecutor(
+                3,
+                5,
+                3,
+                TimeUnit.SECONDS,
+                new LinkedBlockingDeque<>(3),
+                Executors.defaultThreadFactory(),
+                new ThreadPoolExecutor.DiscardOldestPolicy());
+
+        executorService.execute(() -> {
+            int cnt = 0;
+            while (cnt < 10) {
+                synchronized (OBJ) {
+                    if (counter % 3 != 0) {
+                        try {
+                            OBJ.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    } else {
+                        System.out.println("A");
+                        cnt++;
+                        counter++;
+                    }
+                    OBJ.notifyAll();
+                }
+            }
+        });
+
+        executorService.execute(() -> {
+            int cnt = 0;
+            while (cnt < 10) {
+                synchronized (OBJ) {
+                    if (counter % 3 != 1) {
+                        try {
+                            OBJ.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    } else {
+                        System.out.println("B");
+                        cnt++;
+                        counter++;
+                    }
+                    OBJ.notifyAll();
+                }
+            }
+        });
+
+        executorService.execute(() -> {
+            int cnt = 0;
+            while (cnt < 10) {
+                synchronized (OBJ) {
+                    if (counter % 3 != 2) {
+                        try {
+                            OBJ.wait();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    } else {
+                        System.out.println("C");
+                        cnt++;
+                        counter++;
+                    }
+                    OBJ.notifyAll();
+                }
+            }
+        });
+
+        executorService.shutdown();
+    }
+}

Interview/src/printABCExample02.java

@@ -0,0 +1,65 @@
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @Author: zzStar
+ * @Date: 2021/9/9
+ * @Description: 交叉打印ABC，ReentrantLock
+ */
+public class printABCExample02 {
+
+    // 通过state的值来确定是哪个线程打印
+    private static int state = 0;
+
+    private final static Lock LOCK = new ReentrantLock();
+
+    public static void main(String[] args) {
+
+        new Thread(() -> {
+            for (int i = 0; i < 10; ) {
+                LOCK.lock();
+                try {
+                    while (state % 3 == 0) {
+                        System.out.println("A");
+                        state++;
+                        i++;
+                    }
+                } finally {
+                    LOCK.unlock();
+                }
+            }
+        }).start();
+
+        new Thread(() -> {
+            for (int i = 0; i < 10; ) {
+                LOCK.lock();
+                try {
+                    while (state % 3 == 1) {
+                        System.out.println("B");
+                        state++;
+                        i++;
+                    }
+                } finally {
+                    LOCK.unlock();
+                }
+            }
+        }).start();
+
+        new Thread(() -> {
+            for (int i = 0; i < 10; ) {
+                LOCK.lock();
+                try {
+                    while (state % 3 == 2) {
+                        System.out.println("C");
+                        state++;
+                        i++;
+                    }
+                } finally {
+                    LOCK.unlock();
+                }
+            }
+        }).start();
+
+    }
+
+}

Interview/src/printABCExample03.java

@@ -0,0 +1,51 @@
+import java.util.concurrent.*;
+
+/**
+ * @Author: zzStar
+ * @Date: 2021/9/9
+ * @Description: 交叉打印ABC，Semaphore
+ */
+public class printABCExample03 {
+
+    private int times = 10;
+
+    // 只有A 初始信号量为1,第一次获取到的只能是A
+    private static Semaphore A = new Semaphore(1);
+
+    private static Semaphore B = new Semaphore(0);
+
+    private static Semaphore C = new Semaphore(0);
+
+    public static void main(String[] args) {
+
+        ExecutorService executorService = new ThreadPoolExecutor(
+                3,
+                5,
+                3,
+                TimeUnit.SECONDS,
+                new LinkedBlockingDeque<>(3),
+                Executors.defaultThreadFactory(),
+                new ThreadPoolExecutor.DiscardOldestPolicy());
+
+        printABCExample03 printAbc = new printABCExample03();
+        executorService.execute(() -> printAbc.print("A", A, B));
+        executorService.execute(() -> printAbc.print("B", B, C));
+        executorService.execute(() -> printAbc.print("C", C, A));
+
+
+        executorService.shutdown();
+    }
+
+    private void print(String name, Semaphore current, Semaphore next) {
+        for (int i = 0; i < times; i++) {
+            try {
+                current.acquire();
+                System.out.println(name);
+                next.release();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+}