feat: display synchronous and asynchronous callbacks

Author: HY-love-sleep

callback/src/main/java/com/iluwatar/callback/App.java

@@ -37,9 +37,13 @@ public final class App {
   private App() {}
 
   /** Program entry point. */
-  public static void main(final String[] args) throws InterruptedException {
+  public static void main(final String[] args) {
     var task = new SimpleTask();
-    task.executeWith(() -> LOGGER.info("I'm done now."));
-    Thread.sleep(3000);
+
+    LOGGER.info("=== Synchronous callback ===");
+    task.executeWith(() -> LOGGER.info("Sync callback executed."));
+
+    LOGGER.info("=== Asynchronous callback ===");
+    task.executeAsyncWith(() -> LOGGER.info("Async callback executed.")).join();
   }
 }

callback/src/main/java/com/iluwatar/callback/Callback.java

@@ -25,6 +25,7 @@
 package com.iluwatar.callback;
 
 /** Callback interface. */
+@FunctionalInterface
 public interface Callback {
 
   void call();

callback/src/main/java/com/iluwatar/callback/Task.java

@@ -24,21 +24,31 @@
  */
 package com.iluwatar.callback;
 
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
-/** Template-method class for callback hook execution. */
+/**
+ * Template-method class for callback hook execution.
+ *
+ * <p>Provides both synchronous and asynchronous execution with callback support.
+ */
 public abstract class Task {
 
-  /** Execute the task and asynchronously call the callback method upon completion. */
+  /** Execute the task and call the callback method synchronously upon completion. */
   final void executeWith(Callback callback) {
-    CompletableFuture.runAsync(
+    execute();
+    Optional.ofNullable(callback).ifPresent(Callback::call);
+  }
+
+  /** Execute the task and asynchronously call the callback method upon completion. */
+  final CompletableFuture<Void> executeAsyncWith(Callback callback) {
+    return CompletableFuture.runAsync(
         () -> {
           execute();
-          if (callback != null) {
-            callback.call();
-          }
+          Optional.ofNullable(callback).ifPresent(Callback::call);
         });
   }
 
+  /** Actual work to be implemented by subclasses. */
   public abstract void execute();
 }

callback/src/test/java/com/iluwatar/callback/CallbackTest.java

@@ -26,8 +26,9 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -41,31 +42,44 @@ class CallbackTest {
   private Integer callingCount = 0;
 
   @Test
-  void test() throws InterruptedException {
-    CountDownLatch latch = new CountDownLatch(1);
-
-    CountDownLatch finalLatch = latch;
-    Callback callback =
-        () -> {
-          callingCount++;
-          finalLatch.countDown();
-        };
-
+  void testSynchronousCallback() {
+    var counter = new AtomicInteger();
+    Callback callback = counter::incrementAndGet;
     var task = new SimpleTask();
 
+    assertEquals(0, counter.get(), "Initial count should be 0");
     task.executeWith(callback);
-
-    latch.await(5, TimeUnit.SECONDS);
-
-    assertEquals(Integer.valueOf(1), callingCount, "Callback called once");
-
-    callingCount = 0;
-    latch = new CountDownLatch(1);
-
+    assertEquals(1, counter.get(), "Callback should be called once");
     task.executeWith(callback);
+    assertEquals(2, counter.get(), "Callback should be called twice");
+  }
+
+  @Test
+  void testAsynchronousCallback() {
+    var task = new SimpleTask();
 
-    latch.await(5, TimeUnit.SECONDS);
+    var counter1 = new AtomicInteger();
+    final CompletableFuture<Void> future1 = new CompletableFuture<>();
+    Callback callback1 =
+        () -> {
+          counter1.incrementAndGet();
+          future1.complete(null);
+        };
+    var f1 = task.executeAsyncWith(callback1);
+    future1.orTimeout(1, TimeUnit.SECONDS).join();
+    f1.join();
+    assertEquals(1, counter1.get(), "Async callback should increment once");
 
-    assertEquals(Integer.valueOf(1), callingCount, "Callback called once again");
+    var counter2 = new AtomicInteger();
+    final CompletableFuture<Void> future2 = new CompletableFuture<>();
+    Callback callback2 =
+        () -> {
+          counter2.incrementAndGet();
+          future2.complete(null);
+        };
+    var f2 = task.executeAsyncWith(callback2);
+    future2.orTimeout(1, TimeUnit.SECONDS).join();
+    f2.join();
+    assertEquals(1, counter2.get(), "Async callback should increment once again");
   }
 }