Simplify debouncing executor

bentsherman · bentsherman · commit 19b2cbd2ed07 · 2025-05-05T18:48:08.000-05:00
Signed-off-by: Ben Sherman &lt;bentshermann@gmail.com&gt;
diff --git a/src/main/java/nextflow/lsp/services/LanguageService.java b/src/main/java/nextflow/lsp/services/LanguageService.java
@@ -88,9 +88,7 @@
  */
 public abstract class LanguageService {
 
-    private static final int DEBOUNCE_MILLIS = 1_000;
-
-    private static final Object DEBOUNCE_KEY = new Object();
+    private static final long DEBOUNCE_MILLIS = 1_000;
 
     private static Logger log = Logger.getInstance();
 
@@ -101,7 +99,7 @@ public abstract class LanguageService {
     private DebouncingExecutor updateExecutor;
 
     public LanguageService() {
-        this.updateExecutor = new DebouncingExecutor(DEBOUNCE_MILLIS, (key) -> update());
+        this.updateExecutor = new DebouncingExecutor(DEBOUNCE_MILLIS, this::update);
     }
 
     public abstract boolean matchesFile(String uri);
@@ -295,11 +293,11 @@ public List<? extends WorkspaceSymbol> symbol(WorkspaceSymbolParams params) {
 
     protected void updateLater() {
         awaitingUpdate = true;
-        updateExecutor.submit(DEBOUNCE_KEY);
+        updateExecutor.executeLater();
     }
 
     protected void updateNow() {
-        updateExecutor.executeNow(DEBOUNCE_KEY);
+        updateExecutor.executeNow();
     }
 
     protected void awaitUpdate() {
diff --git a/src/main/java/nextflow/lsp/util/DebouncingExecutor.java b/src/main/java/nextflow/lsp/util/DebouncingExecutor.java
@@ -15,104 +15,64 @@
  */
 package nextflow.lsp.util;
 
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Executor service that debounces incoming tasks, so
  * that a task is executed only after not being triggered
- * for a given time period.
- *
- * see: https://stackoverflow.com/questions/4742210/implementing-debounce-in-java/20978973
+ * for a given delay.
  *
  * @author Ben Sherman <bentshermann@gmail.com>
  */
-public class DebouncingExecutor<T> {
-    private int delayMillis;
-    private Consumer<T> action;
-    private ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
-    private ConcurrentHashMap<T, DelayedTask> delayedTasks = new ConcurrentHashMap<>();
+public class DebouncingExecutor {
+    private final long delayMillis;
+    private final Runnable action;
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+    private final AtomicReference<ScheduledFuture<?>> futureRef = new AtomicReference<>();
 
-    public DebouncingExecutor(int delayMillis, Consumer<T> action) {
+    public DebouncingExecutor(long delayMillis, Runnable action) {
         this.delayMillis = delayMillis;
         this.action = action;
     }
 
-    public void submit(T key) {
-        var newTask = new DelayedTask(key);
+    /**
+     * Schedule the action after the configured delay, cancelling
+     * the currently scheduled task if present.
+     */
+    public synchronized void executeLater() {
+        cancelExisting();
 
-        // try until new task was added, or existing task was extended
-        DelayedTask oldTask;
-        do {
-            oldTask = delayedTasks.putIfAbsent(key, newTask);
-            if( oldTask == null )
-                executor.schedule(newTask, delayMillis, TimeUnit.MILLISECONDS);
-        } while( oldTask != null && !oldTask.extend() );
-    }
+        var future = scheduler.schedule(() -> {
+            action.run();
+            futureRef.set(null);
+        }, delayMillis, TimeUnit.MILLISECONDS);
 
-    public void executeNow(T key) {
-        var task = delayedTasks.get(key);
-        if( task != null )
-            task.cancel();
-        action.accept(key);
+        futureRef.set(future);
     }
 
-    public void shutdownNow() {
-        executor.shutdownNow();
+    /**
+     * Execute the action immediately, cancelling the currently
+     * scheduled task if present.
+     */
+    public synchronized void executeNow() {
+        cancelExisting();
+        action.run();
     }
 
-    private class DelayedTask implements Runnable {
-        private T key;
-        private long dueTime;
-        private Object lock = new Object();
-
-        public DelayedTask(T key) {
-            this.key = key;
-            extend();
-        }
-
-        public boolean extend() {
-            synchronized (lock) {
-                if( dueTime < 0 )
-                    return false;
-                dueTime = System.currentTimeMillis() + delayMillis;
-                return true;
-            }
-        }
-
-        public void cancel() {
-            synchronized (lock) {
-                dueTime = -1;
-                delayedTasks.remove(key);
-            }
-        }
-
-        public void run() {
-            synchronized (lock) {
-                var remaining = dueTime - System.currentTimeMillis();
-                if( remaining > 0 ) {
-                    // re-schedule task
-                    executor.schedule(this, remaining, TimeUnit.MILLISECONDS);
-                }
-                else if( dueTime != -1 ) {
-                    // mark task as terminated and invoke callback
-                    dueTime = -1;
-                    try {
-                        action.accept(key);
-                    }
-                    catch( Exception e ) {
-                        System.err.println("exception while invoking debounce callback: " + e.toString());
-                        e.printStackTrace(System.err);
-                    }
-                    finally {
-                        delayedTasks.remove(key);
-                    }
-                }
-            }
-        }
+    private void cancelExisting() {
+        var existing = futureRef.getAndSet(null);
+        if( existing != null && !existing.isDone() )
+            existing.cancel(false);
     }
 
+    /**
+     * Call this method to shut down the executor when no longer needed.
+     */
+    public void shutdown() {
+        scheduler.shutdownNow();
+    }
 }
diff --git a/src/test/groovy/nextflow/lsp/util/DebouncingExecutorTest.groovy b/src/test/groovy/nextflow/lsp/util/DebouncingExecutorTest.groovy
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2024-2025, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package nextflow.lsp.util
+
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+import spock.lang.Specification
+
+/**
+ *
+ * @author Ben Sherman <bentshermann@gmail.com>
+ */
+class DebouncingExecutorSpec extends Specification {
+
+    def "debouncer delays and deduplicates rapid submissions"() {
+        given:
+        def counter = 0
+        def latch = new CountDownLatch(1)
+        def debouncer = new DebouncingExecutor(200, {
+            counter++
+            latch.countDown()
+        })
+
+        when: "executeLater is called rapidly multiple times"
+        debouncer.executeLater()
+        Thread.sleep(50)
+        debouncer.executeLater()
+        Thread.sleep(50)
+        debouncer.executeLater()
+
+        then: "action is only run once after the last delay"
+        latch.await(1, TimeUnit.SECONDS)
+        counter == 1
+
+        cleanup:
+        debouncer.shutdown()
+    }
+
+    def "executeNow runs the action immediately and cancels pending task"() {
+        given:
+        def executed = false
+        def latch = new CountDownLatch(1)
+        def debouncer = new DebouncingExecutor(300, {
+            executed = true
+            latch.countDown()
+        })
+
+        when:
+        debouncer.executeLater()
+        Thread.sleep(100)
+        debouncer.executeNow()
+
+        then: "action runs immediately"
+        latch.await(500, TimeUnit.MILLISECONDS)
+        executed
+
+        cleanup:
+        debouncer.shutdown()
+    }
+
+    def "multiple executeNow calls run the action each time"() {
+        given:
+        def executions = 0
+        def debouncer = new DebouncingExecutor(100, { executions++ })
+
+        when:
+        debouncer.executeNow()
+        debouncer.executeNow()
+        debouncer.executeNow()
+
+        then:
+        executions == 3
+
+        cleanup:
+        debouncer.shutdown()
+    }
+}
