Refactor Task execution to support asynchronous callbacks

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

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

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

@@ -24,15 +24,19 @@
  */
 package com.iluwatar.callback;
 
-import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 
 /** Template-method class for callback hook execution. */
 public abstract class Task {
 
-  /** Execute with callback. */
+  /** Execute the task and asynchronously call the callback method upon completion.*/
   final void executeWith(Callback callback) {
-    execute();
-    Optional.ofNullable(callback).ifPresent(Callback::call);
+    CompletableFuture.runAsync(() -> {
+      execute();
+      if (callback != null) {
+        callback.call();
+      }
+    });
   }
 
   public abstract void execute();

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

@@ -27,6 +27,8 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.junit.jupiter.api.Test;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Add a field as a counter. Every time the callback method is called increment this field. Unit
@@ -39,19 +41,30 @@ class CallbackTest {
   private Integer callingCount = 0;
 
   @Test
-  void test() {
-    Callback callback = () -> callingCount++;
+  void test() throws InterruptedException {
+    CountDownLatch latch = new CountDownLatch(1);
 
-    var task = new SimpleTask();
+    CountDownLatch finalLatch = latch;
+    Callback callback = () -> {
+      callingCount++;
+      finalLatch.countDown();
+    };
 
-    assertEquals(Integer.valueOf(0), callingCount, "Initial calling count of 0");
+    var task = new SimpleTask();
 
     task.executeWith(callback);
 
+    latch.await(5, TimeUnit.SECONDS);
+
     assertEquals(Integer.valueOf(1), callingCount, "Callback called once");
 
+    callingCount = 0;
+    latch = new CountDownLatch(1);
+
     task.executeWith(callback);
 
-    assertEquals(Integer.valueOf(2), callingCount, "Callback called twice");
+    latch.await(5, TimeUnit.SECONDS);
+
+    assertEquals(Integer.valueOf(1), callingCount, "Callback called once again");
   }
 }