Improved task 1195

Author: javadev

src/main/java/g1101_1200/s1195_fizz_buzz_multithreaded/FizzBuzz.java

@@ -1,61 +1,75 @@
 package g1101_1200.s1195_fizz_buzz_multithreaded;
 
-// #Medium #Concurrency #2022_03_03_Time_8_ms_(80.09%)_Space_43.2_MB_(6.17%)
+// #Medium #Concurrency #2024_11_24_Time_6_ms_(94.88%)_Space_43.1_MB_(8.61%)
 
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.IntConsumer;
 
 @SuppressWarnings("java:S1130")
 public class FizzBuzz {
-    private final AtomicInteger count = new AtomicInteger(1);
-
     private final int n;
+    private int current;
 
     public FizzBuzz(int n) {
         this.n = n;
+        this.current = 1;
     }
 
     // printFizz.run() outputs "fizz".
-    public void fizz(Runnable printFizz) {
-        int i;
-        while ((i = count.get()) <= n) {
-            if (i % 3 == 0 && i % 5 != 0) {
-                printFizz.run();
-                count.compareAndSet(i, i + 1);
+    public void fizz(Runnable printFizz) throws InterruptedException {
+        synchronized (this) {
+            while (current <= n) {
+                if (current % 3 == 0 && current % 5 != 0) {
+                    printFizz.run();
+                    current += 1;
+                    notifyAll();
+                } else {
+                    wait();
+                }
             }
         }
     }
 
     // printBuzz.run() outputs "buzz".
-    public void buzz(Runnable printBuzz) {
-        int i;
-        while ((i = count.get()) <= n) {
-            count.get();
-            if (i % 5 == 0 && i % 3 != 0) {
-                printBuzz.run();
-                count.compareAndSet(i, i + 1);
+    public void buzz(Runnable printBuzz) throws InterruptedException {
+        synchronized (this) {
+            while (current <= n) {
+                if (current % 3 != 0 && current % 5 == 0) {
+                    printBuzz.run();
+                    current += 1;
+                    notifyAll();
+                } else {
+                    wait();
+                }
             }
         }
     }
 
     // printFizzBuzz.run() outputs "fizzbuzz".
-    public void fizzbuzz(Runnable printFizzBuzz) {
-        int i;
-        while ((i = count.get()) <= n) {
-            if (i % 15 == 0) {
-                printFizzBuzz.run();
-                count.compareAndSet(i, i + 1);
+    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
+        synchronized (this) {
+            while (current <= n) {
+                if (current % 15 == 0) {
+                    printFizzBuzz.run();
+                    current += 1;
+                    notifyAll();
+                } else {
+                    wait();
+                }
             }
         }
     }
 
     // printNumber.accept(x) outputs "x", where x is an integer.
-    public void number(IntConsumer printNumber) {
-        int i;
-        while ((i = count.get()) <= n) {
-            if (i % 5 != 0 && i % 3 != 0) {
-                printNumber.accept(i);
-                count.compareAndSet(i, i + 1);
+    public void number(IntConsumer printNumber) throws InterruptedException {
+        synchronized (this) {
+            while (current <= n) {
+                if (current % 3 != 0 && current % 5 != 0) {
+                    printNumber.accept(current);
+                    current += 1;
+                    notifyAll();
+                } else {
+                    wait();
+                }
             }
         }
     }

src/test/java/g1101_1200/s1195_fizz_buzz_multithreaded/FizzBuzzTest.java

@@ -14,25 +14,34 @@ void fizzBuzz() throws InterruptedException {
         FizzBuzz fizzBuzz = new FizzBuzz(15);
         new Thread(
                         () -> {
-                            fizzBuzz.fizz(() -> fizz[0]++);
+                            try {
+                                fizzBuzz.fizz(() -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         new Thread(
                         () -> {
-                            fizzBuzz.buzz(() -> fizz[0]++);
+                            try {
+                                fizzBuzz.buzz(() -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         new Thread(
                         () -> {
-                            fizzBuzz.fizzbuzz(() -> fizz[0]++);
+                            try {
+                                fizzBuzz.fizzbuzz(() -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         new Thread(
                         () -> {
-                            fizzBuzz.number(
-                                    value -> {
-                                        fizz[0]++;
-                                    });
+                            try {
+                                fizzBuzz.number(value -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         TimeUnit.MILLISECONDS.sleep(2000);
@@ -45,25 +54,34 @@ void fizzBuzz2() throws InterruptedException {
         FizzBuzz fizzBuzz = new FizzBuzz(5);
         new Thread(
                         () -> {
-                            fizzBuzz.fizz(() -> fizz[0]++);
+                            try {
+                                fizzBuzz.fizz(() -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         new Thread(
                         () -> {
-                            fizzBuzz.buzz(() -> fizz[0]++);
+                            try {
+                                fizzBuzz.buzz(() -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         new Thread(
                         () -> {
-                            fizzBuzz.fizzbuzz(() -> fizz[0]++);
+                            try {
+                                fizzBuzz.fizzbuzz(() -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         new Thread(
                         () -> {
-                            fizzBuzz.number(
-                                    value -> {
-                                        fizz[0]++;
-                                    });
+                            try {
+                                fizzBuzz.number(value -> fizz[0]++);
+                            } catch (InterruptedException e) {
+                            }
                         })
                 .start();
         TimeUnit.MILLISECONDS.sleep(600);