Add couple of tasks which used Semaphores

Author: andrei-punko

src/main/java/by/andd3dfx/multithreading/BuildingH2O.java

@@ -0,0 +1,82 @@
+package by.andd3dfx.multithreading;
+
+import java.util.concurrent.Semaphore;
+
+/**
+ * <pre>
+ * https://leetcode.com/problems/building-h2o/description/
+ *
+ * There are two kinds of threads: oxygen and hydrogen. Your goal is to group these threads to form water molecules.
+ *
+ * There is a barrier where each thread has to wait until a complete molecule can be formed. Hydrogen and oxygen
+ * threads will be given releaseHydrogen and releaseOxygen methods respectively, which will allow them to pass the
+ * barrier. These threads should pass the barrier in groups of three, and they must immediately bond with each other
+ * to form a water molecule. You must guarantee that all the threads from one molecule bond before any other threads
+ * from the next molecule do.
+ *
+ * In other words:
+ *     If an oxygen thread arrives at the barrier when no hydrogen threads are present, it must wait for
+ *     two hydrogen threads.
+ *     If a hydrogen thread arrives at the barrier when no other threads are present, it must wait for
+ *     an oxygen thread and another hydrogen thread.
+ *
+ * We do not have to worry about matching the threads up explicitly; the threads do not necessarily know which
+ * other threads they are paired up with. The key is that threads pass the barriers in complete sets; thus, if we
+ * examine the sequence of threads that bind and divide them into groups of three, each group should contain one
+ * oxygen and two hydrogen threads.
+ *
+ * Write synchronization code for oxygen and hydrogen molecules that enforces these constraints.
+ *
+ * Example 1:
+ * Input: water = "HOH"
+ * Output: "HHO"
+ * Explanation: "HOH" and "OHH" are also valid answers.
+ *
+ * Example 2:
+ * Input: water = "OOHHHH"
+ * Output: "HHOHHO"
+ * Explanation: "HOHHHO", "OHHHHO", "HHOHOH", "HOHHOH", "OHHHOH", "HHOOHH", "HOHOHH" and "OHHOHH" are also valid
+ * answers.
+ *
+ * Constraints:
+ *     3 * n == water.length
+ *     1 <= n <= 20
+ *     water[i] is either 'H' or 'O'.
+ *     There will be exactly 2 * n 'H' in water.
+ *     There will be exactly n 'O' in water.
+ *
+ * Initial code:
+ * class H2O {
+ *     public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+ *         // releaseHydrogen.run() outputs "H". Do not change or remove this line.
+ *         releaseHydrogen.run();
+ *     }
+ *
+ *     public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+ *         // releaseOxygen.run() outputs "O". Do not change or remove this line.
+ * 		   releaseOxygen.run();
+ *     }
+ * }
+ * </pre>
+ */
+public class BuildingH2O {
+
+    private Semaphore hydrogenSemaphore = new Semaphore(2);
+    private Semaphore oxygenSemaphore = new Semaphore(1);
+
+    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+        oxygenSemaphore.acquire();
+
+        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
+        releaseHydrogen.run();
+        hydrogenSemaphore.release();
+    }
+
+    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+        hydrogenSemaphore.acquire(2);
+
+        // releaseOxygen.run() outputs "O". Do not change or remove this line.
+        releaseOxygen.run();
+        oxygenSemaphore.release(2);
+    }
+}

src/main/java/by/andd3dfx/multithreading/PrintInOrder.java

@@ -0,0 +1,80 @@
+package by.andd3dfx.multithreading;
+
+import java.util.concurrent.Semaphore;
+
+/**
+ * <pre>
+ * https://leetcode.com/problems/print-in-order/
+ *
+ * Suppose we have a class:
+ *
+ *  public class Foo {
+ *   public void first() { print("first"); }
+ *   public void second() { print("second"); }
+ *   public void third() { print("third"); }
+ * }
+ *
+ * The same instance of Foo will be passed to three different threads. Thread A will call first(), thread B will
+ * call second(), and thread C will call third(). Design a mechanism and modify the program to ensure that second()
+ * is executed after first(), and third() is executed after second().
+ *
+ * Note:
+ * We do not know how the threads will be scheduled in the operating system, even though the numbers in the input seem
+ * to imply the ordering. The input format you see is mainly to ensure our tests' comprehensiveness.
+ *
+ * Example 1:
+ * Input: nums = [1,2,3]
+ * Output: "firstsecondthird"
+ * Explanation: There are three threads being fired asynchronously. The input [1,2,3] means thread A calls first(),
+ * thread B calls second(), and thread C calls third(). "firstsecondthird" is the correct output.
+ *
+ * Example 2:
+ * Input: nums = [1,3,2]
+ * Output: "firstsecondthird"
+ * Explanation: The input [1,3,2] means thread A calls first(), thread B calls third(), and thread C calls second().
+ * "firstsecondthird" is the correct output.
+ *
+ * Constraints:
+ *      nums is a permutation of [1, 2, 3].
+ *
+ * Initial code:
+ * class H2O {
+ *     public void first(Runnable printFirst) throws InterruptedException {
+ *         // printFirst.run() outputs "first". Do not change or remove this line.
+ *         printFirst.run();
+ *     }
+ *     public void second(Runnable printSecond) throws InterruptedException {
+ *         // printSecond.run() outputs "second". Do not change or remove this line.
+ *         printSecond.run();
+ *     }
+ *     public void third(Runnable printThird) throws InterruptedException {
+ *         // printThird.run() outputs "third". Do not change or remove this line.
+ *         printThird.run();
+ *     }
+ * }
+ * </pre>
+ */
+public class PrintInOrder {
+
+    private Semaphore semaphore2 = new Semaphore(0);
+    private Semaphore semaphore3 = new Semaphore(0);
+
+    public void first(Runnable printFirst) throws InterruptedException {
+        // printFirst.run() outputs "first". Do not change or remove this line.
+        printFirst.run();
+        semaphore2.release();
+    }
+
+    public void second(Runnable printSecond) throws InterruptedException {
+        semaphore2.acquire();
+        // printSecond.run() outputs "second". Do not change or remove this line.
+        printSecond.run();
+        semaphore3.release();
+    }
+
+    public void third(Runnable printThird) throws InterruptedException {
+        semaphore3.acquire();
+        // printThird.run() outputs "third". Do not change or remove this line.
+        printThird.run();
+    }
+}

src/test/java/by/andd3dfx/multithreading/BuildingH2OTest.java

@@ -0,0 +1,58 @@
+package by.andd3dfx.multithreading;
+
+import lombok.SneakyThrows;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class BuildingH2OTest {
+
+    private final int MOLECULES_COUNT = 3;
+
+    @Test
+    public void checkPrintingOrder() throws InterruptedException {
+        var buildingH2O = new BuildingH2O();
+
+        var result = run(buildingH2O);
+
+        assertFalse("String result should not be empty", result.isBlank());
+        assertThat(result.length() % 3).isEqualTo(0);
+
+        for (int i = 0; i < result.length() / 3; i++) {
+            var molecule = result.substring(3 * i, 3 * i + 3);
+            System.out.println(molecule);
+            assertTrue(molecule.equals("OHH") || molecule.equals("HOH") || molecule.equals("HHO"));
+        }
+    }
+
+    private String run(BuildingH2O buildingH2O) throws InterruptedException {
+        var sb = new StringBuilder();
+
+        for (int i = 0; i < MOLECULES_COUNT; i++) {
+            new Thread(
+                    () -> oxygen(buildingH2O, () -> sb.append("O"))
+            ).start();
+        }
+        for (int i = 0; i < 2 * MOLECULES_COUNT; i++) {
+            new Thread(
+                    () -> hydrogen(buildingH2O, () -> sb.append("H"))
+            ).start();
+        }
+
+        Thread.sleep(100);
+
+        return sb.toString();
+    }
+
+    @SneakyThrows
+    private void hydrogen(BuildingH2O buildingH2O, Runnable runnable) {
+        buildingH2O.hydrogen(runnable);
+    }
+
+    @SneakyThrows
+    private void oxygen(BuildingH2O buildingH2O, Runnable runnable) {
+        buildingH2O.oxygen(runnable);
+    }
+}

src/test/java/by/andd3dfx/multithreading/PrintInOrderTest.java

@@ -0,0 +1,51 @@
+package by.andd3dfx.multithreading;
+
+import lombok.SneakyThrows;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PrintInOrderTest {
+
+    @Test
+    public void checkPrintingOrder() throws InterruptedException {
+        var printInOrder = new PrintInOrder();
+
+        // Check task requirements
+        var result = run(printInOrder);
+        assertThat(result).isEqualTo("firstsecondthird");
+
+        // Check could class pass required procedure second time
+        var result2 = run(printInOrder);
+        assertThat(result2).isEqualTo("firstsecondthird");
+    }
+
+    private String run(PrintInOrder printInOrder) throws InterruptedException {
+        var sb = new StringBuilder();
+        var thread1 = new Thread(() -> printFirst(printInOrder, () -> sb.append("first")));
+        var thread2 = new Thread(() -> printSecond(printInOrder, () -> sb.append("second")));
+        var thread3 = new Thread(() -> printThird(printInOrder, () -> sb.append("third")));
+        thread3.start();
+        thread2.start();
+        thread1.start();
+
+        Thread.sleep(50);
+
+        return sb.toString();
+    }
+
+    @SneakyThrows
+    private void printFirst(PrintInOrder printInOrder, Runnable runnable) {
+        printInOrder.first(runnable);
+    }
+
+    @SneakyThrows
+    private void printSecond(PrintInOrder printInOrder, Runnable runnable) {
+        printInOrder.second(runnable);
+    }
+
+    @SneakyThrows
+    private void printThird(PrintInOrder printInOrder, Runnable runnable) {
+        printInOrder.third(runnable);
+    }
+}