refactor: improving code readability for AtomicCompoundActionsExample, CompletableFutureExample, CorrectUsage, OptimizedUsage, ThreadUsingFactory

Author: alxkm

src/main/java/org/alxkm/antipatterns/nonatomiccompoundactions/AtomicCompoundActionsExample.java

@@ -4,7 +4,6 @@
  *
  * To resolve this issue, we can synchronize the method to ensure that the compound action is atomic.
  *
- *
  * In this revised example, the incrementIfLessThan method is synchronized,
  * ensuring that the compound action is performed atomically.
  * This prevents race conditions and ensures correct results.

src/main/java/org/alxkm/antipatterns/startingthreadinconstructor/ThreadUsingFactory.java

@@ -5,7 +5,6 @@
  * Another approach is to use factory methods to create and start the thread,
  * ensuring separation of concerns and better control over the thread lifecycle.
  *
- *
  * In this version, the ThreadUsingFactory class provides a private constructor
  * and a factory method createAndStart to create and start the thread.
  * This ensures that the thread starts at an appropriate time and provides better encapsulation of the thread creation logic.

src/main/java/org/alxkm/antipatterns/threadsinsteadoftasks/CompletableFutureExample.java

@@ -3,7 +3,6 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
-
 /**
  * Another approach is to use CompletableFuture,
  * which is part of the java.util.concurrent package and allows for more flexible task management and asynchronous programming.

src/main/java/org/alxkm/antipatterns/usingthreadsafecollectionsincorrectly/CorrectUsage.java

@@ -10,7 +10,6 @@
  *
  * By synchronizing the addIfAbsent method, we ensure that only one thread can execute it at a time, making the operation atomic.
  *
- *
  * */
 public class CorrectUsage implements BaseListUsage<String> {
     private final List<String> list = new CopyOnWriteArrayList<>();

src/main/java/org/alxkm/antipatterns/usingthreadsafecollectionsincorrectly/OptimizedUsage.java

@@ -3,7 +3,6 @@
 import java.util.Collection;
 import java.util.concurrent.ConcurrentHashMap;
 
-
 /**
  * Another approach is to use a ConcurrentHashMap to achieve atomic check-and-add operations.
  * The ConcurrentHashMap provides thread-safe methods, simplifying the code.