flushQueue = this.flushQueue;
-+ if (flushQueue == null) {
-+ return;
-+ }
-+
-+ flushQueue.add(currentThread);
-+
-+ // double check flush queue
-+ if (this.flushQueue == null) {
-+ return;
-+ }
-+
-+ final long currentCycle = this.flushCycles; // may be opaque read
-+
-+ if (currentCycle == lastCycle) {
-+ Thread.yield();
-+ continue;
-+ }
-+
-+ // force response
-+ this.parked.set(false);
-+ LockSupport.unpark(this);
-+
-+ LockSupport.park("flushing queue executor thread");
-+
-+ // returns whether there are tasks queued, does not return whether there are tasks executing
-+ // this is why we cycle twice twice through flush (we know a pollTask call is made after a flush cycle)
-+ // we really only need to guarantee that the tasks this thread has queued has gone through, and can leave
-+ // tasks queued concurrently that are unsychronized with this thread as undefined behavior
-+ if (this.queue.hasTasks()) {
-+ successes = 0;
-+ } else {
-+ ++successes;
-+ }
-+
-+ } while (successes != 2);
-+
-+ }
-+
-+ /**
-+ * Closes this queue executor's queue and optionally waits for it to empty.
-+ *
-+ * If wait is {@code true}, then the queue will be empty by the time this call completes.
-+ *
-+ *
-+ * This function is MT-Safe.
-+ *
-+ * @param wait If this call is to wait until the queue is empty
-+ * @param killQueue Whether to shutdown this thread's queue
-+ * @return whether this thread shut down the queue
-+ */
-+ public boolean close(final boolean wait, final boolean killQueue) {
-+ boolean ret = !killQueue ? false : this.queue.shutdown();
-+ this.closed = true;
-+
-+ // force thread to respond to the shutdown
-+ this.parked.set(false);
-+ LockSupport.unpark(this);
-+
-+ if (wait) {
-+ this.flush();
-+ }
-+ return ret;
-+ }
-+}
diff --git a/src/main/java/io/papermc/paper/chunk/system/ChunkSystem.java b/src/main/java/io/papermc/paper/chunk/system/ChunkSystem.java
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/io/papermc/paper/chunk/system/ChunkSystem.java
@@ -4502,15 +3387,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+/**
+ * Prioritised RegionFile I/O executor, responsible for all RegionFile access.
+ *
-+ * All functions provided are MT-Safe, however certain ordering constraints are recommended:
++ * All functions provided are MT-Safe, however certain ordering constraints are recommended:
++ *
+ * -
+ * Chunk saves may not occur for unloaded chunks.
+ *
+ * -
+ * Tasks must be scheduled on the chunk scheduler thread.
+ *
-+ * By following these constraints, no chunk data loss should occur with the exception of underlying I/O problems.
-+ *
++ *
++ * By following these constraints, no chunk data loss should occur with the exception of underlying I/O problems.
+ */
+public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+
@@ -4529,16 +3415,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ protected static final RegionFileType[] CACHED_REGIONFILE_TYPES = RegionFileType.values();
+
+ private ChunkDataController getControllerFor(final ServerLevel world, final RegionFileType type) {
-+ switch (type) {
-+ case CHUNK_DATA:
-+ return world.chunkDataControllerNew;
-+ case POI_DATA:
-+ return world.poiDataControllerNew;
-+ case ENTITY_DATA:
-+ return world.entityDataControllerNew;
-+ default:
-+ throw new IllegalStateException("Unknown controller type " + type);
-+ }
++ return switch (type) {
++ case CHUNK_DATA -> world.chunkDataControllerNew;
++ case POI_DATA -> world.poiDataControllerNew;
++ case ENTITY_DATA -> world.entityDataControllerNew;
++ default -> throw new IllegalStateException("Unknown controller type " + type);
++ };
+ }
+
+ /**
@@ -4759,7 +3641,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ }
+
+ /**
-+ * Returns the current {@code CompoundTag} pending for write for the specified chunk & regionfile type.
++ * Returns the current {@code CompoundTag} pending for write for the specified chunk and regionfile type.
+ * Note that this does not copy the result, so do not modify the result returned.
+ *
+ * @param world Specified world.
@@ -4968,15 +3850,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ /**
+ * Schedules the chunk data to be written asynchronously.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
-+ * saves must be scheduled before a chunk is unloaded.
-+ *
-+ *
++ * Impl notes:
++ *
++ * -
++ * This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
++ * saves must be scheduled before a chunk is unloaded.
++ *
++ * -
+ * Writes may be called concurrently, although only the "later" write will go through.
-+ *
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -4994,15 +3877,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ /**
+ * Schedules the chunk data to be written asynchronously.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
-+ * saves must be scheduled before a chunk is unloaded.
-+ *
-+ *
-+ * Writes may be called concurrently, although only the "later" write will go through.
-+ *
++ * Impl notes:
++ *
++ * -
++ * This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
++ * saves must be scheduled before a chunk is unloaded.
++ *
++ * -
++ * Writes may be called concurrently, although only the "later" write will go through.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -5054,13 +3938,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ * {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)}
+ * for single load.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
-+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
-+ * data is undefined behaviour, and can cause deadlock.
-+ *
++ * Impl notes:
++ *
++ * -
++ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++ * data is undefined behaviour, and can cause deadlock.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -5086,13 +3971,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ * {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)}
+ * for single load.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
-+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
-+ * data is undefined behaviour, and can cause deadlock.
-+ *
++ * Impl notes:
++ *
++ * -
++ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++ * data is undefined behaviour, and can cause deadlock.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -5120,13 +4006,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ * then call {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)}
+ * for single load.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
-+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
-+ * data is undefined behaviour, and can cause deadlock.
-+ *
++ * Impl notes:
++ *
++ * -
++ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++ * data is undefined behaviour, and can cause deadlock.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -5154,13 +4041,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ * then call {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)}
+ * for single load.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
-+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
-+ * data is undefined behaviour, and can cause deadlock.
-+ *
++ * Impl notes:
++ *
++ * -
++ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++ * data is undefined behaviour, and can cause deadlock.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -5217,13 +4105,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ * Schedules a load to be executed asynchronously. This task will load the specified regionfile type, and then call
+ * {@code onComplete}.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
-+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
-+ * data is undefined behaviour, and can cause deadlock.
-+ *
++ * Impl notes:
++ *
++ * -
++ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++ * data is undefined behaviour, and can cause deadlock.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -5249,13 +4138,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
+ * Schedules a load to be executed asynchronously. This task will load the specified regionfile type, and then call
+ * {@code onComplete}.
+ *
-+ * Impl notes:
-+ *
-+ *
-+ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
-+ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
-+ * data is undefined behaviour, and can cause deadlock.
-+ *
++ * Impl notes:
++ *
++ * -
++ * The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++ * be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++ * data is undefined behaviour, and can cause deadlock.
++ *
++ *
+ *
+ * @param world Chunk's world
+ * @param chunkX Chunk's x coordinate
@@ -16739,11 +15629,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
this.isSaving = false;
this.resources.close();
@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop