Run version worker delayed

src/main/java/org/jabref/JabRefGUI.java

@@ -58,7 +58,7 @@ public JabRefGUI(Stage mainStage, List<ParserResult> argsDatabases, boolean isBl
 
         openWindow(mainStage);
         new VersionWorker(Globals.BUILD_INFO.getVersion(), Globals.prefs.getVersionPreferences().getIgnoredVersion(), mainFrame.getDialogService(), Globals.TASK_EXECUTOR)
-                .checkForNewVersionAsync(false);
+                .checkForNewVersionDelayed();
     }
 
     private void openWindow(Stage mainStage) {

src/main/java/org/jabref/gui/help/SearchForUpdateAction.java

@@ -23,6 +23,6 @@ public SearchForUpdateAction(BuildInfo buildInfo, VersionPreferences versionPref
     @Override
     public void execute() {
         new VersionWorker(buildInfo.getVersion(), versionPreferences.getIgnoredVersion(), dialogService, taskExecutor)
-                .checkForNewVersionAsync(true);
+                .checkForNewVersionAsync();
     }
 }

src/main/java/org/jabref/gui/help/VersionWorker.java

@@ -4,6 +4,7 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.TimeUnit;
 
 import org.jabref.gui.DialogService;
 import org.jabref.gui.util.BackgroundTask;
@@ -54,16 +55,20 @@ private Optional<Version> getNewVersion() throws IOException {
         return installedVersion.shouldBeUpdatedTo(availableVersions);
     }
 
-    /**
-     * @param manualExecution if this versions check is executed automatically (eg. on startup) or manually by the user
-     */
-    public void checkForNewVersionAsync(boolean manualExecution) {
+    public void checkForNewVersionAsync() {
         BackgroundTask.wrap(this::getNewVersion)
-                      .onSuccess(version -> showUpdateInfo(version, manualExecution))
-                      .onFailure(exception -> showConnectionError(exception, manualExecution))
+                      .onSuccess(version -> showUpdateInfo(version, true))
+                      .onFailure(exception -> showConnectionError(exception, true))
                       .executeWith(taskExecutor);
     }
 
+    public void checkForNewVersionDelayed() {
+        BackgroundTask.wrap(this::getNewVersion)
+                      .onSuccess(version -> showUpdateInfo(version, false))
+                      .onFailure(exception -> showConnectionError(exception, false))
+                      .scheduleWith(taskExecutor, 30, TimeUnit.SECONDS);
+    }
+
     /**
      * Prints the connection problem to the status bar and shows a dialog if it was executed manually
      */

src/main/java/org/jabref/gui/util/BackgroundTask.java

@@ -2,6 +2,7 @@
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
@@ -149,6 +150,10 @@ public Future<?> executeWith(TaskExecutor taskExecutor) {
         return taskExecutor.execute(this);
     }
 
+    public Future<?> scheduleWith(TaskExecutor taskExecutor, long delay, TimeUnit unit) {
+        return taskExecutor.schedule(this, delay, unit);
+    }
+
     /**
      * Sets the {@link Runnable} that is invoked after the task is finished, irrespectively if it was successful or
      * failed with an error.

src/main/java/org/jabref/gui/util/CurrentThreadTaskExecutor.java

@@ -53,6 +53,11 @@ public <V> Future<V> execute(Task<V> task) {
         return task;
     }
 
+    @Override
+    public <V> Future<?> schedule(BackgroundTask<V> task, long delay, TimeUnit unit) {
+        return execute(task);
+    }
+
     @Override
     public void shutdown() {
         // Nothing to do here

src/main/java/org/jabref/gui/util/DefaultTaskExecutor.java

@@ -8,6 +8,8 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
 import javafx.application.Platform;
@@ -25,7 +27,8 @@ public class DefaultTaskExecutor implements TaskExecutor {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(DefaultTaskExecutor.class);
 
-    private static final ExecutorService EXECUTOR = Executors.newFixedThreadPool(5);
+    private final ExecutorService executor = Executors.newFixedThreadPool(5);
+    private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(2);
 
     /**
      *
@@ -95,13 +98,19 @@ public <V> Future<V> execute(BackgroundTask<V> task) {
 
     @Override
     public <V> Future<V> execute(Task<V> task) {
-        EXECUTOR.submit(task);
+        executor.submit(task);
         return task;
     }
 
+    @Override
+    public <V> Future<?> schedule(BackgroundTask<V> task, long delay, TimeUnit unit) {
+        return scheduledExecutor.schedule(getJavaFXTask(task), delay, unit);
+    }
+
     @Override
     public void shutdown() {
-        EXECUTOR.shutdownNow();
+        executor.shutdownNow();
+        scheduledExecutor.shutdownNow();
     }
 
     private <V> Task<V> getJavaFXTask(BackgroundTask<V> task) {

src/main/java/org/jabref/gui/util/TaskExecutor.java

@@ -1,6 +1,7 @@
 package org.jabref.gui.util;
 
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 import javafx.concurrent.Task;
 
@@ -29,6 +30,18 @@ public interface TaskExecutor {
      */
     <V> Future<V> execute(Task<V> task);
 
+    /**
+     * Submits a one-shot task that becomes enabled after the given delay.
+     *
+     * @param task  the task to execute
+     * @param delay the time from now to delay execution
+     * @param unit  the time unit of the delay parameter
+     * @return a ScheduledFuture representing pending completion of
+     *         the task and whose {@code get()} method will return
+     *         {@code null} upon completion
+     */
+    <V> Future<?> schedule(BackgroundTask<V> task, long delay, TimeUnit unit);
+
     /**
      * Shutdown the task executor.
      */