Updated Upstream (Paper)

2025-12-29 03:29:09 +00:00 · 2023-02-13 20:34:58 +01:00
parent 0601d22510
commit a056d4338e
58 changed files with 34 additions and 90 deletions
--- a/patches/server/0144-Thread-aware-lock-utility.patch
+++ b/patches/server/0144-Thread-aware-lock-utility.patch
@@ -0,0 +1,127 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martijn Muijsers <martijnmuijsers@live.nl>
+Date: Fri, 3 Feb 2023 23:01:51 +0100
+Subject: [PATCH] Thread-aware lock utility
+
+License: AGPL-3.0 (https://www.gnu.org/licenses/agpl-3.0.html)
+Gale - https://galemc.org
+
+diff --git a/src/main/java/org/galemc/gale/concurrent/ThreadAwareNonReentrantLock.java b/src/main/java/org/galemc/gale/concurrent/ThreadAwareNonReentrantLock.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8c14d90d1a907adf994070cbe5d62f1fbfd8d9c8
+--- /dev/null
+++ b/src/main/java/org/galemc/gale/concurrent/ThreadAwareNonReentrantLock.java
+@@ -0,0 +1,113 @@
+// Gale - thread-aware lock utility
+
+package org.galemc.gale.concurrent;
+
+import net.minecraft.server.MinecraftServer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+
+/**
+ * A wrapper for a non-reentrant {@link Lock}, that is aware when the thread that already holds this lock
+ * is trying to acquire it again (for example by calling {@link #tryLock}), and throws an exception in that case.
+ * <br>
+ * This is useful for debugging purposes when a {@link Lock} is not supposed to be reachable
+ * from any code that is executed while the lock is being held.
+ */
+public class ThreadAwareNonReentrantLock implements CheckableLock {
+
+    private final CheckableLock innerLock;
+
+    /**
+     * The {@link Thread} that currently holds this lock, or null if no thread currently holds this lock.
+     */
+    private volatile @Nullable Thread currentHoldingThread;
+
+    public ThreadAwareNonReentrantLock(CheckableLock innerLock) {
+        this.innerLock = innerLock;
+    }
+
+    @Override
+    public void lock() {
+        var currentThread = Thread.currentThread();
+        if (this.currentHoldingThread == currentThread) {
+            IllegalStateException exception = new IllegalStateException("Called lock() on a " + this.getClass().getSimpleName() + " from the thread (" + currentThread + ") that was already holding it");
+            MinecraftServer.LOGGER.error(exception.getMessage() + ", at:");
+            exception.printStackTrace();
+            throw exception;
+        }
+        this.innerLock.lock();
+        this.currentHoldingThread = currentThread;
+    }
+
+    @Override
+    public void lockInterruptibly() throws InterruptedException {
+        var currentThread = Thread.currentThread();
+        if (this.currentHoldingThread == currentThread) {
+            IllegalStateException exception = new IllegalStateException("Called lockInterruptibly() on a " + this.getClass().getSimpleName() + " from the thread (" + currentThread + ") that was already holding it");
+            MinecraftServer.LOGGER.error(exception.getMessage() + ", at:");
+            exception.printStackTrace();
+            throw exception;
+        }
+        this.innerLock.lockInterruptibly();
+        this.currentHoldingThread = currentThread;
+    }
+
+    @Override
+    public boolean tryLock() {
+        var currentThread = Thread.currentThread();
+        if (this.currentHoldingThread == currentThread) {
+            IllegalStateException exception = new IllegalStateException("Called tryLock() on a " + this.getClass().getSimpleName() + " from the thread (" + currentThread + ") that was already holding it");
+            MinecraftServer.LOGGER.error(exception.getMessage() + ", at:");
+            exception.printStackTrace();
+            throw exception;
+        }
+        if (this.innerLock.tryLock()) {
+            this.currentHoldingThread = currentThread;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean tryLock(long time, @NotNull TimeUnit unit) throws InterruptedException {
+        var currentThread = Thread.currentThread();
+        if (this.currentHoldingThread == currentThread) {
+            IllegalStateException exception = new IllegalStateException("Called tryLock() on a " + this.getClass().getSimpleName() + " from the thread (" + currentThread + ") that was already holding it");
+            MinecraftServer.LOGGER.error(exception.getMessage() + ", at:");
+            exception.printStackTrace();
+            throw exception;
+        }
+        if (this.innerLock.tryLock(time, unit)) {
+            this.currentHoldingThread = currentThread;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void unlock() {
+        this.innerLock.unlock();
+        this.currentHoldingThread = null;
+    }
+
+    @NotNull
+    @Override
+    public Condition newCondition() {
+        return this.innerLock.newCondition();
+    }
+
+    @Override
+    public boolean isLocked() {
+        return this.innerLock.isLocked();
+    }
+
+    @Override
+    public boolean isHeldByCurrentThread() {
+        return this.innerLock.isHeldByCurrentThread();
+    }
+
+}