A lot of changes!

New load-balancing thread manager! This thread manager, based on a load function decided per-thread, dynamically chooses which threads should get their own thread and which should be left to be remapped to run on the main thread. This is currently used for the dimension threading pool; however, it's toggleable via a config option.

Moved around a lot of thread management and IMC stuff to its own classes.
A lot of miscellaneous changes to a lot of classes to reduce *auto-boxing/unboxing*!

Finally fixed LAN servers not properly deconstructing the distance manager when all players other than the host leave.
Fixed an issue with distance manager interfering across worlds. The distance manager should now be completely world-independent. This means that a player with a distance thread in one dimension will not interfere with a player in another dimension with their own distance thread, regardless of relative position to each-other (inside the dim coordinates).

Author: BallOfEnergy1

src/main/java/com/gamma/spool/api/SpoolAPI.java

@@ -52,6 +52,6 @@ public void registerStatisticReceiver(String modid, Class<? extends IStatisticRe
             "Mod " + modid
                 + " attempted to register a Spool statistic receiver without the IStatisticReceiver interface.");
 
-        FMLInterModComms.sendMessage(modid, "registerStatisticReceiver", statisticReceiverClass.getName());
+        FMLInterModComms.sendMessage("spool", "registerStatisticReceiver", statisticReceiverClass.getName());
     }
 }

src/main/java/com/gamma/spool/api/statistics/ICache.java

@@ -1,19 +1,17 @@
 package com.gamma.spool.api.statistics;
 
-import com.gamma.spool.util.caching.CachedItem;
-
 public interface ICache {
 
     void invalidate();
 
-    CachedItem<?>[] getCacheItems();
+    ICachedItem<?>[] getCacheItems();
 
     @SuppressWarnings("SameReturnValue") // Purely because there's only one cache.
     String getNameForDebug();
 
     default long calculateSize() {
         long size = 0;
-        for (CachedItem<?> cache : this.getCacheItems()) {
+        for (ICachedItem<?> cache : this.getCacheItems()) {
             if (cache == null) continue;
             size += cache.calculateSize();
         }

src/main/java/com/gamma/spool/api/statistics/ICachedItem.java

@@ -5,4 +5,6 @@ public interface ICachedItem<T> {
     T getItem();
 
     void setItem(T item);
+
+    long calculateSize();
 }

src/main/java/com/gamma/spool/commands/CommandSpool.java

@@ -18,7 +18,7 @@
 import com.gamma.spool.config.DistanceThreadingConfig;
 import com.gamma.spool.config.ThreadManagerConfig;
 import com.gamma.spool.config.ThreadsConfig;
-import com.gamma.spool.core.Spool;
+import com.gamma.spool.core.SpoolManagerOrchestrator;
 import com.gamma.spool.thread.KeyedPoolThreadManager;
 import com.gamma.spool.thread.ManagerNames;
 import com.gamma.spool.thread.ThreadManager;
@@ -61,7 +61,7 @@ public void processCommand(ICommandSender sender, String[] args) {
                 if (!ThreadsConfig.isDimensionThreadingEnabled())
                     throw new CommandException("Dimension threading disabled.");
 
-                KeyedPoolThreadManager dimensionManager = (KeyedPoolThreadManager) Spool.REGISTERED_THREAD_MANAGERS
+                KeyedPoolThreadManager dimensionManager = (KeyedPoolThreadManager) SpoolManagerOrchestrator.REGISTERED_THREAD_MANAGERS
                     .get(ManagerNames.DIMENSION);
 
                 sender.addChatMessage(new ChatComponentText("Thread stats:"));
@@ -94,7 +94,7 @@ public void processCommand(ICommandSender sender, String[] args) {
                 if (!ThreadsConfig.isDistanceThreadingEnabled())
                     throw new CommandException("Distance threading disabled.");
 
-                KeyedPoolThreadManager distanceManager = (KeyedPoolThreadManager) Spool.REGISTERED_THREAD_MANAGERS
+                KeyedPoolThreadManager distanceManager = (KeyedPoolThreadManager) SpoolManagerOrchestrator.REGISTERED_THREAD_MANAGERS
                     .get(ManagerNames.DISTANCE);
 
                 sender.addChatMessage(new ChatComponentText("Thread stats:"));
@@ -130,7 +130,7 @@ public void processCommand(ICommandSender sender, String[] args) {
                 if (!ThreadsConfig.isThreadedChunkLoadingEnabled())
                     throw new CommandException("Chunk threading disabled.");
 
-                ThreadManager chunkLoadingManager = (ThreadManager) Spool.REGISTERED_THREAD_MANAGERS
+                ThreadManager chunkLoadingManager = (ThreadManager) SpoolManagerOrchestrator.REGISTERED_THREAD_MANAGERS
                     .get(ManagerNames.CHUNK_LOAD);
 
                 sender.addChatMessage(new ChatComponentText("Thread stats:"));
@@ -232,6 +232,16 @@ public void processCommand(ICommandSender sender, String[] args) {
                     EnumChatFormatting.ITALIC + "   allowProcessingDuringSleep: "
                         + ThreadManagerConfig.allowProcessingDuringSleep
                         + EnumChatFormatting.RESET));
+            sender.addChatMessage(
+                new ChatComponentText(
+                    EnumChatFormatting.ITALIC + "   useLoadBalancingDimensionThreadManager: "
+                        + ThreadManagerConfig.useLoadBalancingDimensionThreadManager
+                        + EnumChatFormatting.RESET));
+            sender.addChatMessage(
+                new ChatComponentText(
+                    EnumChatFormatting.ITALIC + "   loadBalancerFrequency: "
+                        + ThreadManagerConfig.loadBalancerFrequency
+                        + EnumChatFormatting.RESET));
             sender.addChatMessage(
                 new ChatComponentText(
                     EnumChatFormatting.ITALIC + "   enableSpoolWatchdog: "

src/main/java/com/gamma/spool/concurrent/ConcurrentChunk.java

@@ -1,6 +1,7 @@
 package com.gamma.spool.concurrent;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
@@ -76,7 +77,7 @@ public class ConcurrentChunk extends Chunk implements IAtomic {
     public AtomicIntegerArray heightMap = new AtomicIntegerArray(256);
     public final AtomicInteger heightMapMinimum = new AtomicInteger(0);
 
-    public final AtomicReferenceArray<Boolean> updateSkylightColumns;
+    public final AtomicReference<boolean[]> updateSkylightColumns;
 
     public final AtomicReferenceArray<ConcurrentExtendedBlockStorage> storageArrays;
 
@@ -86,10 +87,9 @@ public class ConcurrentChunk extends Chunk implements IAtomic {
     public ConcurrentChunk(World p_i1995_1_, int p_i1995_2_, int p_i1995_3_) {
         super(p_i1995_1_, p_i1995_2_, p_i1995_3_);
         this.queuedLightChecks.set(4096);
-        this.updateSkylightColumns = new AtomicReferenceArray<>(new Boolean[256]);
-        for (int i = 0; i < updateSkylightColumns.length(); i++) {
-            updateSkylightColumns.set(i, false); // Fill the array.
-        }
+        this.updateSkylightColumns = new AtomicReference<>(new boolean[256]);
+        // Fill the array.
+        Arrays.fill(updateSkylightColumns.get(), false);
 
         for (int i = 0; i < entityLists.length; i++) {
             entityLists[i] = ObjectLists.synchronize(new ObjectArrayList<Entity>());
@@ -315,7 +315,7 @@ public void generateSkylightMap() {
      * Propagates a given sky-visible block's light value downward and upward to neighboring blocks as necessary.
      */
     private void propagateSkylightOcclusion(int p_76595_1_, int p_76595_2_) {
-        this.updateSkylightColumns.set(p_76595_1_ + p_76595_2_ * 16, true);
+        this.updateSkylightColumns.get()[p_76595_1_ + p_76595_2_ * 16] = true;
         this.isGapLightingUpdated.set(true);
     }
 
@@ -324,12 +324,8 @@ private void recheckGaps(boolean p_150803_1_) {
         if (this.worldObj.doChunksNearChunkExist(this.xPosition * 16 + 8, 0, this.zPosition * 16 + 8, 16)) {
             for (int i = 0; i < 16; ++i) {
                 for (int j = 0; j < 16; ++j) {
-                    if (this.updateSkylightColumns.get(i + j * 16)) {
-
-                        boolean expected;
-                        do {
-                            expected = this.updateSkylightColumns.get(i + j * 16);
-                        } while (expected && !this.updateSkylightColumns.compareAndSet(i + j * 16, expected, false));
+                    if (this.updateSkylightColumns.get()[i + j * 16]) {
+                        this.updateSkylightColumns.get()[i + j * 16] = false;
 
                         int k = this.getHeightValue(i, j);
                         int l = this.xPosition * 16 + i;

src/main/java/com/gamma/spool/concurrent/providers/ConcurrentChunkProviderServer.java

@@ -30,7 +30,7 @@
 import com.gamma.spool.concurrent.ConcurrentChunk;
 import com.gamma.spool.concurrent.providers.gen.IFullAsync;
 import com.gamma.spool.config.ThreadsConfig;
-import com.gamma.spool.core.Spool;
+import com.gamma.spool.core.SpoolManagerOrchestrator;
 import com.gamma.spool.thread.ManagerNames;
 import com.gamma.spool.util.concurrent.CompletedFuture;
 import com.gamma.spool.util.concurrent.interfaces.IAtomic;
@@ -295,7 +295,7 @@ private Chunk originalLoadChunk1(int x, int z) {
         // Load the chunk (includes generating!)
         if (!(futureTask instanceof CompletedFuture)) { // Only run the task if it needs to be run. Reasonable, right?
             if (ThreadsConfig.isThreadedChunkLoadingEnabled()) {
-                Spool.REGISTERED_THREAD_MANAGERS.get(ManagerNames.CHUNK_LOAD)
+                SpoolManagerOrchestrator.REGISTERED_THREAD_MANAGERS.get(ManagerNames.CHUNK_LOAD)
                     .execute(futureTask);
             } else {
                 futureTask.run();

src/main/java/com/gamma/spool/config/ThreadManagerConfig.java

@@ -24,6 +24,16 @@ public class ThreadManagerConfig {
     @Config.Name("Drop tasks on timeout?")
     public static boolean dropTasksOnTimeout;
 
+    @Config.Comment("If the dimension thread manager should use a load-balancing implementation. This can very slightly increase overhead, however it greatly improves performance when the server's dimension count is greater than the pool size.")
+    @Config.DefaultBoolean(true)
+    @Config.Name("Use load-balancing dimension thread manager?")
+    public static boolean useLoadBalancingDimensionThreadManager;
+
+    @Config.Comment("How often (every n ticks) the load-balancing pools should re-balance. Lower values lead to slower response times (for rebalancing), potentially causing lag spikes, however higher values increase overhead significantly.")
+    @Config.DefaultInt(5)
+    @Config.Name("Load balanced pool frequency")
+    public static int loadBalancerFrequency;
+
     @Config.Comment("If the managers should optimize lambdas (pulling scoped values) using Consumers. Sometimes increases performance, sometimes doesn't.")
     @Config.DefaultBoolean(true)
     @Config.Name("Use lambda optimization?")