Use mini2Dx-lock-provider for concurrency

Author: tomcashman

CHANGES

@@ -1,3 +1,6 @@
+[1.6.0]
+- Use mini2Dx-lock-provider for concurrency
+
 [1.5.3]
 - Add wfc() alias for waitForCompletion()
 

build.gradle

@@ -46,7 +46,8 @@ subprojects {
 
 		bcelVersion='5.2'
 		javaPoetVersion='1.11.1'
-		
+		lockProviderVersion='1.1.0'
+
 		junitVersion='4.11'
 		jmockVersion='2.5.1'
 	}
@@ -144,6 +145,8 @@ project(":" + rootProject.name + "-core") {
 	description = "miniscript core library"
 
 	dependencies {
+		compile "org.mini2Dx:mini2Dx-lock-provider:$lockProviderVersion"
+
 		testCompile "junit:junit:$junitVersion"
 		testCompile "org.jmock:jmock-junit4:$jmockVersion"
 		testCompile "org.jmock:jmock-legacy:$jmockVersion"

core/src/main/java/org/mini2Dx/miniscript/core/GameFuture.java

@@ -23,11 +23,11 @@
  */
 package org.mini2Dx.miniscript.core;
 
+import org.mini2Dx.miniscript.core.exception.ScriptSkippedException;
+
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import org.mini2Dx.miniscript.core.exception.ScriptSkippedException;
-
 /**
  * Represents a task that will complete in-game at a future time
  */

core/src/main/java/org/mini2Dx/miniscript/core/GameScriptingEngine.java

@@ -23,19 +23,22 @@
  */
 package org.mini2Dx.miniscript.core;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Scanner;
-import java.util.Set;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
-
+import org.mini2Dx.lockprovider.Locks;
+import org.mini2Dx.lockprovider.jvm.JvmLocks;
 import org.mini2Dx.miniscript.core.exception.InsufficientCompilersException;
 import org.mini2Dx.miniscript.core.exception.NoSuchScriptException;
 import org.mini2Dx.miniscript.core.notification.ScriptNotification;
+import org.mini2Dx.miniscript.core.util.ReadWriteArrayQueue;
+import org.mini2Dx.miniscript.core.util.ReadWriteMap;
+import org.mini2Dx.miniscript.core.util.ReadWritePriorityQueue;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.*;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Provides scripting functionality to your game
@@ -48,13 +51,15 @@ public abstract class GameScriptingEngine implements Runnable {
 	 */
 	public static GameScriptingEngine MOST_RECENT_INSTANCE = null;
 
+	public static Locks LOCK_PROVIDER = new JvmLocks();
+
 	private final ScriptInvocationPool scriptInvocationPool = new ScriptInvocationPool();
-	private final Queue<ScriptInvocation> scriptInvocations = new PriorityBlockingQueue<>(64);
-	final Queue<ScriptNotification> scriptNotifications = new ConcurrentLinkedQueue<ScriptNotification>();
+	private final Queue<ScriptInvocation> scriptInvocations = new ReadWritePriorityQueue<>();
+	final Queue<ScriptNotification> scriptNotifications = new ReadWriteArrayQueue<ScriptNotification>();
 
-	final Queue<GameFuture> queuedFutures = new ConcurrentLinkedQueue<GameFuture>();
-	final Map<Integer, GameFuture> runningFutures = new ConcurrentHashMap<Integer, GameFuture>();
-	private final Map<Integer, ScriptExecutionTask<?>> runningScripts = new ConcurrentHashMap<Integer, ScriptExecutionTask<?>>();
+	final Queue<GameFuture> queuedFutures = new ReadWriteArrayQueue<>();
+	final Map<Integer, GameFuture> runningFutures = new ReadWriteMap<Integer, GameFuture>();
+	private final Map<Integer, ScriptExecutionTask<?>> runningScripts = new ReadWriteMap<Integer, ScriptExecutionTask<?>>();
 	private final Set<Integer> completedFutures = new HashSet<Integer>();
 	private final Set<Integer> completedScripts = new HashSet<Integer>();
 

core/src/main/java/org/mini2Dx/miniscript/core/PerThreadClasspathGameScript.java

@@ -23,11 +23,12 @@
  */
 package org.mini2Dx.miniscript.core;
 
+import org.mini2Dx.miniscript.core.util.ReadWriteMap;
+
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 public class PerThreadClasspathGameScript<S> extends GameScript<S> {
-	private final Map<Long, S> threadToScriptMapping = new ConcurrentHashMap<Long, S>();
+	private final Map<Long, S> threadToScriptMapping = new ReadWriteMap<>();
 	private final S content;
 
 	public PerThreadClasspathGameScript(S content) {

core/src/main/java/org/mini2Dx/miniscript/core/PerThreadGameScript.java

@@ -23,15 +23,16 @@
  */
 package org.mini2Dx.miniscript.core;
 
+import org.mini2Dx.miniscript.core.util.ReadWriteMap;
+
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * An implementation of {@link GameScript} for language runtimes where
  * a script must be compiled on a per thread basis
  */
 public class PerThreadGameScript<S> extends GameScript<S> {
-	private final Map<Long, S> threadToScriptMapping = new ConcurrentHashMap<Long, S>();
+	private final Map<Long, S> threadToScriptMapping = new ReadWriteMap<>();
 	private final String content;
 
 	public PerThreadGameScript(String content) {

core/src/main/java/org/mini2Dx/miniscript/core/ScriptBindings.java

@@ -24,8 +24,6 @@
 package org.mini2Dx.miniscript.core;
 
 import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * A mapping of variable names to objects passed to a script

core/src/main/java/org/mini2Dx/miniscript/core/ScriptExecutionTask.java

@@ -23,15 +23,15 @@
  */
 package org.mini2Dx.miniscript.core;
 
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-
 import org.mini2Dx.miniscript.core.exception.ScriptSkippedException;
 import org.mini2Dx.miniscript.core.notification.ScriptExceptionNotification;
 import org.mini2Dx.miniscript.core.notification.ScriptSkippedNotification;
 import org.mini2Dx.miniscript.core.notification.ScriptSuccessNotification;
 
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
 /**
  * Executes a script
  */

core/src/main/java/org/mini2Dx/miniscript/core/ScriptInvocationPool.java

@@ -23,15 +23,16 @@
  */
 package org.mini2Dx.miniscript.core;
 
+import org.mini2Dx.miniscript.core.util.ReadWriteArrayQueue;
+
 import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
 
 /**
  * Provides a pool of reusable {@link ScriptInvocation} instances to reduce
  * object allocation
  */
 public class ScriptInvocationPool {
-	private final Queue<ScriptInvocation> pool = new ConcurrentLinkedQueue<ScriptInvocation>();
+	private final Queue<ScriptInvocation> pool = new ReadWriteArrayQueue<>();
 
 	/**
 	 * Allocate a {@link ScriptInvocation} instance

core/src/main/java/org/mini2Dx/miniscript/core/util/AbstractConcurrentQueue.java

@@ -0,0 +1,187 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Thomas Cashman
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.mini2Dx.miniscript.core.util;
+
+import org.mini2Dx.lockprovider.ReadWriteLock;
+import org.mini2Dx.miniscript.core.GameScriptingEngine;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Queue;
+
+public abstract class AbstractConcurrentQueue<E> implements Queue<E> {
+	private final ReadWriteLock lock = GameScriptingEngine.LOCK_PROVIDER.newReadWriteLock();
+
+	private final Queue<E> internalQueue;
+
+	public AbstractConcurrentQueue(Queue<E> internalQueue) {
+		this.internalQueue = internalQueue;
+	}
+
+	@Override
+	public int size() {
+		lock.lockRead();
+		final int result = internalQueue.size();
+		lock.unlockRead();
+		return result;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size() == 0;
+	}
+
+	@Override
+	public boolean contains(Object o) {
+		lock.lockRead();
+		final boolean result = internalQueue.contains(o);
+		lock.unlockRead();
+		return result;
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public Object[] toArray() {
+		lock.lockRead();
+		try {
+			return internalQueue.toArray();
+		} finally {
+			lock.unlockRead();
+		}
+	}
+
+	@Override
+	public <T> T[] toArray(T[] a) {
+		lock.lockRead();
+		try {
+			return internalQueue.toArray(a);
+		} finally {
+			lock.unlockRead();
+		}
+	}
+
+	@Override
+	public boolean add(E e) {
+		lock.lockWrite();
+		final boolean result = internalQueue.add(e);
+		lock.unlockWrite();
+		return result;
+	}
+
+	@Override
+	public boolean remove(Object o) {
+		lock.lockWrite();
+		final boolean result = internalQueue.remove(o);
+		lock.unlockWrite();
+		return result;
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> c) {
+		lock.lockRead();
+		final boolean result = internalQueue.containsAll(c);
+		lock.unlockRead();
+		return result;
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends E> c) {
+		lock.lockWrite();
+		final boolean result = internalQueue.addAll(c);
+		lock.unlockWrite();
+		return result;
+	}
+
+	@Override
+	public boolean removeAll(Collection<?> c) {
+		lock.lockWrite();
+		final boolean result = internalQueue.removeAll(c);
+		lock.unlockWrite();
+		return result;
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> c) {
+		lock.lockWrite();
+		final boolean result = internalQueue.retainAll(c);
+		lock.unlockWrite();
+		return result;
+	}
+
+	@Override
+	public void clear() {
+		lock.lockWrite();
+		internalQueue.clear();
+		lock.unlockWrite();
+	}
+
+	@Override
+	public boolean offer(E e) {
+		return add(e);
+	}
+
+	@Override
+	public E remove() {
+		lock.lockWrite();
+		try {
+			return internalQueue.remove();
+		} finally {
+			lock.unlockWrite();
+		}
+	}
+
+	@Override
+	public E poll() {
+		lock.lockWrite();
+		try {
+			return internalQueue.poll();
+		} finally {
+			lock.unlockWrite();
+		}
+	}
+
+	@Override
+	public E element() {
+		lock.lockRead();
+		try {
+			return internalQueue.element();
+		} finally {
+			lock.unlockRead();
+		}
+	}
+
+	@Override
+	public E peek() {
+		lock.lockRead();
+		try {
+			return internalQueue.peek();
+		} finally {
+			lock.unlockRead();
+		}
+	}
+}