fix(hotreload): Unset INSTANCE of executor on shutdown (#324)

---------

Co-authored-by: Gastón Fournier <gaston@getunleash.io>

Author: chriswk

src/main/java/io/getunleash/util/UnleashScheduledExecutor.java

@@ -1,16 +1,16 @@
 package io.getunleash.util;
 
-import io.getunleash.lang.Nullable;
 import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.ScheduledFuture;
 
 public interface UnleashScheduledExecutor {
-    @Nullable
-    ScheduledFuture setInterval(Runnable command, long initialDelaySec, long periodSec)
+
+    void setInterval(Runnable command, long initialDelaySec, long periodSec)
             throws RejectedExecutionException;
 
     Future<Void> scheduleOnce(Runnable runnable);
 
-    public default void shutdown() {}
+    default void shutdown() {}
+
+    default void shutdownNow() {}
 }

src/main/java/io/getunleash/util/UnleashScheduledExecutorImpl.java

@@ -37,14 +37,12 @@ public static synchronized UnleashScheduledExecutorImpl getInstance() {
     }
 
     @Override
-    public @Nullable ScheduledFuture setInterval(
-            Runnable command, long initialDelaySec, long periodSec) {
+    public void setInterval(Runnable command, long initialDelaySec, long periodSec) {
         try {
-            return scheduledThreadPoolExecutor.scheduleAtFixedRate(
+            scheduledThreadPoolExecutor.scheduleAtFixedRate(
                     command, initialDelaySec, periodSec, TimeUnit.SECONDS);
         } catch (RejectedExecutionException ex) {
             LOG.error("Unleash background task crashed", ex);
-            return null;
         }
     }
 
@@ -54,7 +52,16 @@ public Future<Void> scheduleOnce(Runnable runnable) {
     }
 
     @Override
-    public void shutdown() {
+    public synchronized void shutdown() {
         this.scheduledThreadPoolExecutor.shutdown();
+        this.executorService.shutdown();
+        INSTANCE = null;
+    }
+
+    @Override
+    public synchronized void shutdownNow() {
+        this.scheduledThreadPoolExecutor.shutdownNow();
+        this.executorService.shutdownNow();
+        INSTANCE = null;
     }
 }

src/test/java/io/getunleash/HotReloadSchedulerReuseTest.java

@@ -0,0 +1,72 @@
+package io.getunleash;
+
+import io.getunleash.util.UnleashConfig;
+import org.junit.jupiter.api.*;
+
+import java.lang.reflect.Field;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class HotReloadSchedulerReuseTest {
+
+
+    private UnleashConfig baseConfig() {
+        return UnleashConfig.builder()
+            .appName("hot-reload-test-app")
+            .instanceId("A")
+            .unleashAPI("http://localhost")    // never hit
+            .synchronousFetchOnInitialisation(false)
+            .fetchTogglesInterval(100)
+            .sendMetricsInterval(100)
+            .build();
+    }
+
+    private ScheduledThreadPoolExecutor currentGlobalExecutor() throws Exception {
+        Class<?> execClazz = Class.forName("io.getunleash.util.UnleashScheduledExecutorImpl");
+        Field instance = execClazz.getDeclaredField("INSTANCE");
+        instance.setAccessible(true);
+        Object inst = instance.get(null);
+        if (inst == null) return null;
+
+        Field pool = execClazz.getDeclaredField("scheduledThreadPoolExecutor");
+        pool.setAccessible(true);
+        return (ScheduledThreadPoolExecutor) pool.get(inst);
+    }
+
+    @Test
+    void secondClientDoesNotReuseSchedulerExecutor() throws Exception {
+        // 1) Create first client; let it schedule background tasks
+        DefaultUnleash first = new DefaultUnleash(
+            baseConfig()
+        );
+
+        // Let it initialize/schedule
+        Thread.sleep(150);
+
+        // Snapshot the global executor
+        ScheduledThreadPoolExecutor execBeforeShutdown = currentGlobalExecutor();
+        assertThat(execBeforeShutdown).isNotNull();
+        assertThat(execBeforeShutdown.isShutdown()).isFalse();
+
+        // 2) Simulate app stop (DevTools restart) by shutting the client
+        first.shutdown();
+
+        // After shutdown, the global executor instance is properly reset to null
+        ScheduledThreadPoolExecutor execAfterShutdown = currentGlobalExecutor();
+        assertThat(execAfterShutdown).isNull();
+
+        // 3) "Reloaded app": create a second client in the same JVM (statics still around)
+        DefaultUnleash second = new DefaultUnleash(
+            baseConfig()
+        );
+
+        // 4) Assert that the second client creates a fresh executor (not reusing the terminated one)
+        ScheduledThreadPoolExecutor execUsedBySecond = currentGlobalExecutor();
+        assertThat(execUsedBySecond).isNotNull();
+        assertThat(execUsedBySecond.isShutdown()).isFalse(); // it's a new one
+
+        // Clean up
+        second.shutdown();
+    }
+}

src/test/java/io/getunleash/SynchronousTestExecutor.java

@@ -13,10 +13,10 @@ public class SynchronousTestExecutor implements UnleashScheduledExecutor {
     private static final Logger LOG = LoggerFactory.getLogger(SynchronousTestExecutor.class);
 
     @Override
-    public ScheduledFuture setInterval(Runnable command, long initialDelaySec, long periodSec)
+    public void setInterval(Runnable command, long initialDelaySec, long periodSec)
             throws RejectedExecutionException {
         LOG.warn("i will only do this once");
-        return scheduleOnce(command);
+        scheduleOnce(command);
     }
 
     @Override