Forgotten synchronization improving

Author: alxkm

src/main/java/org/alxkm/antipatterns/forgottensynchronization/CounterExample.java

@@ -1,6 +1,5 @@
 package org.alxkm.antipatterns.forgottensynchronization;
 
-
 /***
  *
  * Forgotten synchronization is a common concurrency issue in Java where a method or block of code that should be synchronized is not,
@@ -12,14 +11,14 @@
  *
  * */
 public class CounterExample {
-    private int count = 0;
+    private int counter = 0;
 
     /**
      * Increments the counter by one.
      * This method is not synchronized, leading to potential race conditions.
      */
     public void increment() {
-        count++;
+        counter++;
     }
 
     /**
@@ -28,7 +27,35 @@ public void increment() {
      *
      * @return the current count value.
      */
-    public int getCount() {
-        return count;
+    public int getCounter() {
+        return counter;
+    }
+
+
+    public static void main(String[] args) throws InterruptedException {
+        CounterExample counter = new CounterExample();
+
+        // Create two threads that both call increment 1000 times
+        Thread t1 = new Thread(() -> {
+            for (int i = 0; i < 1000; i++) {
+                counter.increment();
+            }
+        });
+
+        Thread t2 = new Thread(() -> {
+            for (int i = 0; i < 1000; i++) {
+                counter.increment();
+            }
+        });
+
+        t1.start();
+        t2.start();
+
+        // Wait for threads to finish
+        t1.join();
+        t2.join();
+
+        // This will likely print a number less than 2000 due to race conditions
+        System.out.println("Final Counter Value (without synchronization): " + counter.getCounter());
     }
 }

src/main/java/org/alxkm/antipatterns/forgottensynchronization/CounterResolution.java

@@ -0,0 +1,55 @@
+package org.alxkm.antipatterns.forgottensynchronization;
+
+/***
+ *
+ * To resolve this issue, we need to synchronize the methods to ensure that only one thread can access these critical sections at a time.
+ *
+ * */
+public class CounterSynchronized {
+    private int counter = 0;
+
+    /**
+     * Increments the counter by one.
+     * This method is synchronized to prevent race conditions.
+     */
+    public synchronized void increment() {
+        counter++;
+    }
+
+    /**
+     * Returns the current value of the counter.
+     * This method is synchronized to ensure consistent read operations.
+     *
+     * @return the current count value.
+     */
+    public synchronized int getCounter() {
+        return counter;
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        CounterSynchronized counter = new CounterSynchronized();
+
+        // Create two threads that both call increment 1000 times
+        Thread t1 = new Thread(() -> {
+            for (int i = 0; i < 1000; i++) {
+                counter.increment();
+            }
+        });
+
+        Thread t2 = new Thread(() -> {
+            for (int i = 0; i < 1000; i++) {
+                counter.increment();
+            }
+        });
+
+        t1.start();
+        t2.start();
+
+        // Wait for threads to finish
+        t1.join();
+        t2.join();
+
+        // This will always print 2000 because of proper synchronization
+        System.out.println("Final Counter Value (with synchronization): " + counter.getCounter());
+    }
+}