Create a single place for all chunky thread/executors to be registered

NotStirred · NotStirred · commit 05c83993afdb · 2026-07-08T16:12:48.000+01:00
Closes #1893 - Allows chunky to close them on shutdown without a System.exit() - Additionally provides an api to wait on all chunky threads to be joined.
diff --git a/chunky/src/java/se/llbit/chunky/main/Chunky.java b/chunky/src/java/se/llbit/chunky/main/Chunky.java
@@ -48,6 +48,7 @@
 import se.llbit.log.Log;
 import se.llbit.log.Receiver;
 import se.llbit.util.TaskTracker;
+import se.llbit.util.concurrent.ChunkyThread;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -241,6 +242,12 @@ public static void main(final String[] args) {
         exitCode = 2;
       }
     }
+
+    ChunkyThread.interruptAndJoinAll();
+    ForkJoinPool commonThreads = Chunky.getCommonThreads();
+    commonThreads.shutdownNow(); // ForkJoinPool doesn't return any tasks that were awaiting execution (all canceled).
+    // We don't use the ForkJoinPool commonPool in chunky, but if we did there is no shutdown available so nothing changes.
+
     if (exitCode != 0) {
       System.exit(exitCode);
     }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/DefaultRenderManager.java b/chunky/src/java/se/llbit/chunky/renderer/DefaultRenderManager.java
@@ -28,6 +28,7 @@
 import se.llbit.chunky.resources.BitmapImage;
 import se.llbit.log.Log;
 import se.llbit.math.ColorUtil;
+import se.llbit.util.concurrent.ChunkyThread;
 import se.llbit.util.TaskTracker;
 
 import java.time.Duration;
@@ -52,7 +53,7 @@
  * <p>All available final renderers are stored in {@code renderers} and preview renderers
  * are stored in {@code previewRenderers}.
  */
-public class DefaultRenderManager extends Thread implements RenderManager {
+public class DefaultRenderManager extends ChunkyThread implements RenderManager {
   /**
    * Map containing all the final render {@code Renderer}s. The renderer corresponding to
    * {@code getRendererName()} is used when a render is requested.
diff --git a/chunky/src/java/se/llbit/chunky/renderer/RenderWorkerPool.java b/chunky/src/java/se/llbit/chunky/renderer/RenderWorkerPool.java
@@ -18,6 +18,7 @@
 package se.llbit.chunky.renderer;
 
 import se.llbit.log.Log;
+import se.llbit.util.concurrent.ChunkyThread;
 
 import java.util.ArrayList;
 import java.util.Random;
@@ -39,7 +40,7 @@ public interface Factory {
     RenderWorkerPool create(int threads, long seed);
   }
 
-  public static class RenderWorker extends Thread {
+  public static class RenderWorker extends ChunkyThread {
     private final RenderWorkerPool pool;
 
     public final Random random;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/AsynchronousSceneManager.java b/chunky/src/java/se/llbit/chunky/renderer/scene/AsynchronousSceneManager.java
@@ -26,6 +26,7 @@
 import se.llbit.chunky.world.RegionPosition;
 import se.llbit.chunky.world.World;
 import se.llbit.log.Log;
+import se.llbit.util.concurrent.ChunkyThread;
 import se.llbit.util.TaskTracker;
 
 import java.io.File;
@@ -41,7 +42,7 @@
  *
  * @author Jesper Öqvist <jesper@llbit.se>
  */
-public class AsynchronousSceneManager extends Thread implements SceneManager {
+public class AsynchronousSceneManager extends ChunkyThread implements SceneManager {
 
   private final SynchronousSceneManager sceneManager;
   private final LinkedBlockingQueue<Runnable> taskQueue;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -62,6 +62,7 @@
 import se.llbit.nbt.Tag;
 import se.llbit.util.*;
 import se.llbit.util.annotation.NotNull;
+import se.llbit.util.concurrent.ChunkyThread;
 import se.llbit.util.io.PositionalInputStream;
 import se.llbit.util.io.ZipExport;
 import se.llbit.util.mojangapi.MinecraftProfile;
@@ -858,7 +859,7 @@ public synchronized void loadChunks(TaskTracker taskTracker, World world, Map<Re
       int[] cubeWorldBlocks = new int[16*16*16];
       int[] cubeWaterBlocks = new int[16*16*16];
 
-      ExecutorService executor = Executors.newSingleThreadExecutor();
+      ExecutorService executor = ChunkyThread.addExecutorService(Executors::newSingleThreadExecutor);
 
       ChunkData[] regionParsingDataArray = new ChunkData[MCRegion.CHUNKS_X * MCRegion.CHUNKS_Z];
       ChunkData[] chunkLoadingDataArray = new ChunkData[MCRegion.CHUNKS_X * MCRegion.CHUNKS_Z];
diff --git a/chunky/src/java/se/llbit/chunky/ui/ChunkMap.java b/chunky/src/java/se/llbit/chunky/ui/ChunkMap.java
@@ -52,6 +52,7 @@
 import se.llbit.chunky.world.region.MCRegion;
 import se.llbit.log.Log;
 import se.llbit.math.*;
+import se.llbit.util.concurrent.ChunkyThread;
 
 import java.awt.*;
 import java.io.File;
@@ -115,7 +116,7 @@ public class ChunkMap implements ChunkUpdateListener, ChunkViewListener, CameraV
   private volatile boolean scheduledUpdate = false;
   private volatile long lastRedraw = 0;
   private Runnable onViewDragged = () -> {};
-  private ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+  private final ScheduledExecutorService executor = ChunkyThread.addExecutorService(Executors::newSingleThreadScheduledExecutor);
 
   private boolean shouldDrawPlayers = true;
 
diff --git a/chunky/src/java/se/llbit/chunky/ui/ChunkyFx.java b/chunky/src/java/se/llbit/chunky/ui/ChunkyFx.java
@@ -82,7 +82,6 @@ public void stop() throws Exception {
     if(mainStage != null) {
       PersistentSettings.setWindowPosition(new WindowPosition(mainStage));
     }
-    System.exit(0);
   }
 
   public static void startChunkyUI(Chunky chunkyInstance) {
diff --git a/chunky/src/java/se/llbit/chunky/ui/controller/ResourcePackChooserController.java b/chunky/src/java/se/llbit/chunky/ui/controller/ResourcePackChooserController.java
@@ -49,6 +49,7 @@
 import se.llbit.json.JsonParser;
 import se.llbit.log.Log;
 import se.llbit.util.MinecraftText;
+import se.llbit.util.concurrent.ChunkyThread;
 
 import java.awt.*;
 import java.io.File;
@@ -451,7 +452,7 @@ public void populate(
 
   private static class PackListItem {
 
-    private final static Executor PACK_PARSER_EXECUTOR = Executors.newSingleThreadExecutor();
+    private final static Executor PACK_PARSER_EXECUTOR = ChunkyThread.addExecutorService(Executors::newSingleThreadExecutor);
 
     private static PackListItem DEFAULT = null;
 
diff --git a/chunky/src/java/se/llbit/chunky/ui/controller/SceneChooserController.java b/chunky/src/java/se/llbit/chunky/ui/controller/SceneChooserController.java
@@ -36,6 +36,7 @@
 import se.llbit.json.JsonObject;
 import se.llbit.json.JsonParser;
 import se.llbit.log.Log;
+import se.llbit.util.concurrent.ChunkyThread;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -64,6 +65,8 @@ public class SceneChooserController implements Initializable {
 
   private Stage stage;
 
+  private static final Executor loadExecutor = ChunkyThread.addExecutorService(Executors::newSingleThreadExecutor);
+
   private ChunkyFxController controller;
 
   private static final HashMap<FileTimeCache, SceneListItem> sceneListCache = new HashMap<>();
@@ -219,7 +222,6 @@ public void setStage(Stage stage) {
 
   private void populateSceneTable(File sceneDir) {
     this.sceneTbl.setPlaceholder(new Label("Loading scenes…"));
-    Executor loadExecutor = Executors.newSingleThreadExecutor();
 
     loadExecutor.execute(() -> {
       List<SceneListItem> scenes = new ArrayList<>();
diff --git a/chunky/src/java/se/llbit/chunky/world/ChunkTopographyUpdater.java b/chunky/src/java/se/llbit/chunky/world/ChunkTopographyUpdater.java
@@ -16,6 +16,8 @@
  */
 package se.llbit.chunky.world;
 
+import se.llbit.util.concurrent.ChunkyThread;
+
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
@@ -25,7 +27,7 @@
  *
  * @author Jesper Öqvist (jesper@llbit.se)
  */
-public class ChunkTopographyUpdater extends Thread {
+public class ChunkTopographyUpdater extends ChunkyThread {
 
   private final Set<Chunk> queue = new HashSet<>();
 
diff --git a/chunky/src/java/se/llbit/chunky/world/SkymapTexture.java b/chunky/src/java/se/llbit/chunky/world/SkymapTexture.java
@@ -25,6 +25,7 @@
 import se.llbit.math.QuickMath;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector4;
+import se.llbit.util.concurrent.ChunkyThread;
 import se.llbit.util.ImageTools;
 
 /**
@@ -35,7 +36,7 @@
  */
 public class SkymapTexture extends Texture {
 
-  class TexturePreprocessor extends Thread {
+  class TexturePreprocessor extends ChunkyThread {
     private final int x0;
     private final int x1;
     private final int y0;
diff --git a/chunky/src/java/se/llbit/chunky/world/region/RegionChangeWatcher.java b/chunky/src/java/se/llbit/chunky/world/region/RegionChangeWatcher.java
@@ -20,13 +20,14 @@
 import se.llbit.chunky.map.WorldMapLoader;
 import se.llbit.chunky.renderer.ChunkViewListener;
 import se.llbit.chunky.world.ChunkView;
+import se.llbit.util.concurrent.ChunkyThread;
 
 /**
  * Monitors filesystem for changes to region files.
  *
  * @author Jesper Öqvist <jesper@llbit.se>
  */
-public abstract class RegionChangeWatcher extends Thread implements ChunkViewListener {
+public abstract class RegionChangeWatcher extends ChunkyThread implements ChunkViewListener {
   protected final WorldMapLoader mapLoader;
   protected final MapView mapView;
   protected volatile ChunkView view = ChunkView.EMPTY;
diff --git a/chunky/src/java/se/llbit/chunky/world/region/RegionParser.java b/chunky/src/java/se/llbit/chunky/world/region/RegionParser.java
@@ -23,6 +23,7 @@
 import se.llbit.chunky.map.WorldMapLoader;
 import se.llbit.chunky.world.*;
 import se.llbit.log.Log;
+import se.llbit.util.concurrent.ChunkyThread;
 import se.llbit.util.Mutable;
 
 /**
@@ -34,7 +35,7 @@
  *
  * @author Jesper Öqvist (jesper@llbit.se)
  */
-public class RegionParser extends Thread {
+public class RegionParser extends ChunkyThread {
 
   private final WorldMapLoader mapLoader;
   private final RegionQueue queue;
diff --git a/chunky/src/java/se/llbit/util/concurrent/ChunkyThread.java b/chunky/src/java/se/llbit/util/concurrent/ChunkyThread.java
@@ -0,0 +1,169 @@
+package se.llbit.util.concurrent;
+
+import se.llbit.chunky.main.Chunky;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
+
+/**
+ * {@link Thread}/{@link ExecutorService} resource management.
+ * <h4>The goal of this glass is to primarily:</h4>
+ * <ul>
+ *   <li>Ensure all chunky threads (even daemons) are interrupted and given a chance clean up before getting killed by
+ *       the runtime on termination.</li>
+ *   <li>Within the non-termination {@link Runtime} shutdown sequence give guarantees to shut down hooks about the state
+ *       of chunky.</li>
+ * </ul>
+ *
+ * <h2>Usage</h2>
+ * <p>{@link Thread Threads} in chunky should extend this class, and {@link ExecutorService executor services} should
+ * be created with {@link #addExecutorService(Function)} to allow chunky to interrupt and join them before chunky closes.</p>
+ *
+ */
+public class ChunkyThread extends Thread {
+  /*
+   * All operations lock.
+   * When interruptAndJoinAll is called, additional threads/executors can't be added preventing later joins from
+   * waiting on threads that have not been interrupted.
+   */
+  private static final AtomicBoolean isShutdown = new AtomicBoolean(false);
+  private static final Collection<Thread> threads = new ArrayList<>();
+  private static final Collection<ExecutorService> executorServices = new ArrayList<>();
+
+  /**
+   * Add a {@link Thread} to be interrupted and joined by chunky on shutdown
+   *
+   * @throws IllegalStateException When calling after {@link #interruptAndJoinAll()} has been called.
+   */
+  public synchronized static <T extends Thread> T addThread(T thread) {
+    if (isShutdown.get()) {
+      throw new IllegalStateException("Creating a thread as chunky is stopping.");
+    }
+    threads.add(thread);
+    return thread;
+  }
+
+  /**
+   * Add an {@link ExecutorService} to be interrupted and joined by chunky on shutdown
+   *
+    @throws IllegalStateException When calling after {@link #interruptAndJoinAll()} has been called.
+   */
+  public synchronized static <E extends ExecutorService> E addExecutorService(Function<ThreadFactory, E> executorServiceSupplier) {
+    if (isShutdown.get()) {
+      throw new IllegalStateException("Creating an executor service as chunky is stopping.");
+    }
+    E e = executorServiceSupplier.apply(ChunkyThread::new);
+    executorServices.add(e);
+    return e;
+  }
+
+  /**
+   * Await the joining of all threads managed by chunky
+   *
+   * <p>This method is always safe to call.</p>
+   *
+   * <p><b><i>WARNING: calling this from any thread registered with {@link #addThread(Thread)} may <u>deadlock</u>.</i></b></p>
+   */
+  public synchronized static void joinAll() {
+    for (Thread thread : threads) {
+      try {
+        thread.join();
+      } catch (InterruptedException e) {
+        // ignored
+      }
+    }
+    for (ExecutorService executorService : executorServices) {
+      try {
+        executorService.awaitTermination(1, TimeUnit.MINUTES);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+    }
+  }
+
+  /**
+   * Interrupt and then await joining of all threads managed by chunky.
+   *
+   * <p>This method is always safe to call.</p>
+   *
+   * <p><b><i>WARNING: calling this from any thread registered with {@link #addThread(Thread)} may <u>deadlock</u>.</i></b></p>
+   * <p>Only to be called by {@link Chunky}</p>
+   */
+  public synchronized static void interruptAndJoinAll() {
+    assert Thread.currentThread().getName().equals("main");
+    isShutdown.set(true);
+
+    // shut down executorServices BEFORE threads because they recreate their threads when they are interrupted and stop
+    // causing an infinite hang.
+    for (ExecutorService executorService : executorServices) {
+      executorService.shutdownNow();
+    }
+
+    for (Thread thread : ChunkyThread.threads) {
+      thread.interrupt();
+    }
+    for (Thread thread : ChunkyThread.threads) {
+      try {
+        thread.join();
+      } catch (InterruptedException e) {
+        // ignored
+      }
+    }
+  }
+
+  private void setDefaults() {
+    this.setDaemon(true);
+    addThread(this);
+  }
+
+  /* Constructors from super */
+  public ChunkyThread() {
+    super();
+    setDefaults();
+  }
+
+  public ChunkyThread(Runnable task) {
+    super(task);
+    setDefaults();
+  }
+
+  public ChunkyThread(ThreadGroup group, Runnable task) {
+    super(group, task);
+    setDefaults();
+  }
+
+  public ChunkyThread(String name) {
+    super(name);
+    setDefaults();
+  }
+
+  public ChunkyThread(ThreadGroup group, String name) {
+    super(group, name);
+    setDefaults();
+  }
+
+  public ChunkyThread(Runnable task, String name) {
+    super(task, name);
+    setDefaults();
+  }
+
+  public ChunkyThread(ThreadGroup group, Runnable task, String name) {
+    super(group, task, name);
+    setDefaults();
+  }
+
+  public ChunkyThread(ThreadGroup group, Runnable task, String name, long stackSize) {
+    super(group, task, name, stackSize);
+    setDefaults();
+  }
+
+  public ChunkyThread(ThreadGroup group, Runnable task, String name, long stackSize, boolean inheritInheritableThreadLocals) {
+    super(group, task, name, stackSize, inheritInheritableThreadLocals);
+    setDefaults();
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,7 @@`
`48`	`48`	`import se.llbit.log.Log;`
`49`	`49`	`import se.llbit.log.Receiver;`
`50`	`50`	`import se.llbit.util.TaskTracker;`
	`51`	`+import se.llbit.util.concurrent.ChunkyThread;`
`51`	`52`
`52`	`53`	`import java.io.File;`
`53`	`54`	`import java.io.FileInputStream;`
`@@ -241,6 +242,12 @@ public static void main(final String[] args) {`
`241`	`242`	`exitCode = 2;`
`242`	`243`	`}`
`243`	`244`	`}`
	`245`	`+`
	`246`	`+ ChunkyThread.interruptAndJoinAll();`
	`247`	`+ ForkJoinPool commonThreads = Chunky.getCommonThreads();`
	`248`	`+ commonThreads.shutdownNow(); // ForkJoinPool doesn't return any tasks that were awaiting execution (all canceled).`
	`249`	`+ // We don't use the ForkJoinPool commonPool in chunky, but if we did there is no shutdown available so nothing changes.`
	`250`	`+`
`244`	`251`	`if (exitCode != 0) {`
`245`	`252`	`System.exit(exitCode);`
`246`	`253`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,6 @@ public void stop() throws Exception {`
`82`	`82`	`if(mainStage != null) {`
`83`	`83`	`PersistentSettings.setWindowPosition(new WindowPosition(mainStage));`
`84`	`84`	`}`
`85`		`- System.exit(0);`
`86`	`85`	`}`
`87`	`86`
`88`	`87`	`public static void startChunkyUI(Chunky chunkyInstance) {`