Add locks to Hashset

src/main/java/org/bukkit/craftbukkit/util/LongHashset.java

@@ -1,12 +1,25 @@
 package org.bukkit.craftbukkit.util;
-import static org.bukkit.craftbukkit.util.Java15Compat.Arrays_copyOf;
 
-public class LongHashset extends LongHash {
+import static org.bukkit.craftbukkit.util.Java15Compat.Arrays_copyOf;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
+
+public class LongHashset extends LongHash
+{
     long values[][][] = new long[256][][];
     int count = 0;
+    ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
+    ReadLock rl = rwl.readLock();
+    WriteLock wl = rwl.writeLock();
 
     public boolean isEmpty() {
+        rl.lock();
+        try {
             return count == 0;
+        } finally {
+            rl.unlock();
+        }
     }
 
     public void add(int msw, int lsw) {
@@ -16,90 +29,142 @@ public class LongHashset extends LongHash {
     public void add(long key) {
         int mainIdx = (int) (key & 255);
         int outerIdx = (int) ((key >> 32) & 255);
+        rl.lock();
+        try {
+            wl.lock();
+            try {
                 long outer[][] = values[mainIdx], inner[];
-        if(outer == null) values[mainIdx] = outer = new long[256][];
+                if (outer == null)
+                    values[mainIdx] = outer = new long[256][];
                 inner = outer[outerIdx];
                 if (inner == null) {
+                    synchronized (this) {
                         outer[outerIdx] = inner = new long[1];
                         inner[0] = key;
                         count++;
                     }
-        else {
+                } else {
                     int i;
                     for (i = 0; i < inner.length; i++) {
                         if (inner[i] == key) {
                             return;
                         }
                     }
-            outer[outerIdx] = inner = Arrays_copyOf(inner, i+1);
+                    inner = Arrays_copyOf(inner, i + 1);
+                    outer[outerIdx] = inner;
                     inner[i] = key;
                     count++;
                 }
+            } finally {
+                wl.unlock();
+            }
+        } finally {
+            rl.unlock();
+        }
     }
 
     public boolean containsKey(long key) {
         int mainIdx = (int) (key & 255);
         int outerIdx = (int) ((key >> 32) & 255);
+        rl.lock();
+        try {
             long outer[][] = values[mainIdx], inner[];
-        if(outer == null) return false;
+            if (outer == null)
+                return false;
             inner = outer[outerIdx];
-        if(inner == null) return false;
+            if (inner == null)
+                return false;
             else {
                 for (long entry : inner) {
-                if(entry == key) return true;
+                    if (entry == key)
+                        return true;
                 }
                 return false;
             }
+        } finally {
+            rl.unlock();
+        }
     }
 
     public void remove(long key) {
+        rl.lock();
+        try {
             long[][] outer = this.values[(int) (key & 255)];
-        if (outer == null) return;
+            if (outer == null)
+                return;
 
             long[] inner = outer[(int) ((key >> 32) & 255)];
-        if (inner == null) return;
+            if (inner == null)
+                return;
 
             int max = inner.length - 1;
             for (int i = 0; i <= max; i++) {
                 if (inner[i] == key) {
+                    wl.lock();
+                    try {
                         count--;
                         if (i != max) {
                             inner[i] = inner[max];
                         }
                         outer[(int) ((key >> 32) & 255)] = (max == 0 ? null : Arrays_copyOf(inner, max));
+                    } finally {
+                        wl.unlock();
+                    }
                     return;
                 }
             }
+        } finally {
+            rl.unlock();
+        }
     }
 
     public long popFirst() {
+        rl.lock();
+        try {
             for (long[][] outer : values) {
-            if(outer == null) continue;
+                if (outer == null)
+                    continue;
                 for (int i = 0; i < outer.length; i++) {
                     long[] inner = outer[i];
-                if(inner == null || inner.length == 0) continue;
+                    if (inner == null || inner.length == 0)
+                        continue;
+                    wl.lock();
+                    try {
                         count--;
                         long ret = inner[inner.length - 1];
                         outer[i] = Arrays_copyOf(inner, inner.length - 1);
                         return ret;
+                    } finally {
+                        wl.unlock();
+                    }
 
                 }
             }
+        } finally {
+            rl.unlock();
+        }
         return 0;
     }
 
     public long[] keys() {
         int index = 0;
+        rl.lock();
+        try {
             long ret[] = new long[count];
             for (long[][] outer : values) {
-            if(outer == null) continue;
+                if (outer == null)
+                    continue;
                 for (long[] inner : outer) {
-                if(inner == null) continue;
+                    if (inner == null)
+                        continue;
                     for (long entry : inner) {
                         ret[index++] = entry;
                     }
                 }
             }
             return ret;
+        } finally {
+            rl.unlock();
+        }
     }
 }