new MaxSizeMap for caching stuff, ThreadManager for easy run

Author: fquirin

src/main/java/net/b07z/sepia/server/core/data/CmdMap.java

@@ -25,11 +25,21 @@ public class CmdMap {
 	private List<String> permissions;
 
 	@SuppressWarnings("unchecked")
+	/**
+	 * Import command map from JSON.
+	 * @param entry
+	 */
 	public CmdMap(JSONObject entry){
 		this.command = JSON.getString(entry, "command");
 		this.services = new ArrayList<>((JSONArray)entry.get("services"));
 		this.permissions = new ArrayList<>((JSONArray)entry.get("permissions"));
 	}
+	/**
+	 * Create a new command map.
+	 * @param command
+	 * @param services
+	 * @param permissions
+	 */
 	public CmdMap(String command, List<String> services, List<String> permissions){
 		this.command = command;
 		this.services = services;
@@ -52,6 +62,10 @@ public boolean equals(Object map){
 			return false;
 		}
 	}
+	@Override
+	public String toString(){
+		return (this.command + " - services: " + this.services.size());
+	}
 
 	public String getCommand(){
 		return command;

src/main/java/net/b07z/sepia/server/core/java/MaxSizeMap.java

@@ -0,0 +1,47 @@
+package net.b07z.sepia.server.core.java;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * A Map implementation that uses {@LinkedHashMap} to features to keep the size limited to a maximum and drop the oldest entry on overflow.<br>
+ * NOTE: Check the constructor on notes about concurrency.  
+ * 
+ * @author Florian Quirin
+ *
+ * @param <K>
+ * @param <V>
+ */
+public class MaxSizeMap<K, V> extends LinkedHashMap<K, V> {
+
+	private static final long serialVersionUID = 1L;
+	
+	private int maxKeysSize;
+	
+	/**
+	 * Create a {@LinkedHashMap} that automatically removes the oldest entry when size is exceeded.<br>
+	 * <br>
+	 * IMPORTANT: This map (as is it basically a linked hash map) can run into concurrency problems, use {@link #getSynchronizedMap(int)}
+	 * or build your own Collections.synchronizedMap(...) if you access the list from multiple threads.
+	 * @param maxSize
+	 */
+	public MaxSizeMap(int maxSize){
+		super(maxSize + 1);
+		this.maxKeysSize = maxSize;
+	}
+	/**
+	 * Create a synchronized version of this map.
+	 * @param maxSize
+	 * @return
+	 */
+	public static <T> Map<String, T> getSynchronizedMap(int maxSize){
+		return Collections.synchronizedMap(new MaxSizeMap<String, T>(maxSize));
+	}
+	
+	@Override
+    protected boolean removeEldestEntry(final Map.Entry<K, V> eldest) {
+        return size() > maxKeysSize;
+    }
+
+}

src/main/java/net/b07z/sepia/server/core/tools/ThreadManager.java

@@ -0,0 +1,77 @@
+package net.b07z.sepia.server.core.tools;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A class to easily run threaded tasks.
+ * 
+ * @author Florian Quirin
+ *
+ */
+public class ThreadManager {
+	
+	/**
+	 * Interface to define a task. Has one method 'run(Object o)' that should make appropriate type casting of the object.   
+	 * Usually used via lambda expression, e.g.:<br>
+	 * <br>
+	 * (Object o) -> { System.out.println(o.toString()); }
+	 */
+	public static interface ThreadManagerTask {
+		public void run(Object o);
+	}
+	
+	/**
+	 * Run a given task ({@link ThreadManagerTask}) with parameters in a certain number of threads
+	 * and wait for completion or timeout.
+	 * @param numOfThreads - number of threads to use
+	 * @param myTask - {@link ThreadManagerTask} implementation (has to overwrite run(Object o) method).
+	 * @param parameters - List of objects used in myTask (one for each task)
+	 * @param timeoutMs - wait at most this time (ms)
+	 * @return
+	 * @throws Exception
+	 */
+	public static boolean runTasks(int numOfThreads, ThreadManagerTask myTask, List<?> parameters,
+			long timeoutMs) throws Exception {
+		
+		//Create executor
+		ExecutorService threadPool = Executors.newFixedThreadPool(numOfThreads);
+		
+		//Run all tasks
+		for (Object o : parameters){
+			Runnable worker = () -> { 
+				myTask.run(o);
+			};
+			threadPool.execute(worker);
+		}
+		
+		//Await termination
+		try{
+			awaitTerminationAfterShutdown(threadPool, timeoutMs);
+			return true;
+			
+	    }catch (InterruptedException ex){
+	        ex.printStackTrace();
+	        return false;
+	    }
+	}
+	/**
+	 * Await thread pool termination or force quit on timeout.
+	 */
+	private static void awaitTerminationAfterShutdown(ExecutorService threadPool, 
+			long timeoutMs) throws InterruptedException {
+	    threadPool.shutdown();
+	    try{
+	        if (!threadPool.awaitTermination(timeoutMs, TimeUnit.MILLISECONDS)) {
+	            threadPool.shutdownNow();
+	        }
+	    }catch (InterruptedException ex){
+	        threadPool.shutdownNow();
+	        Thread.currentThread().interrupt();
+	        throw ex;
+	    }
+	}
+
+}

src/test/java/tools/Test_MaxSizeMap.java

@@ -0,0 +1,53 @@
+package tools;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import net.b07z.sepia.server.core.data.CmdMap;
+import net.b07z.sepia.server.core.java.MaxSizeMap;
+import net.b07z.sepia.server.core.tools.ThreadManager;
+
+public class Test_MaxSizeMap {
+	
+	private static final class UserTestData {
+		public String name;
+		public List<CmdMap> map;
+		public UserTestData(String name, List<CmdMap> map){
+			this.name = name;
+			this.map = map;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		
+		//TODO: make this a real JUnit test
+		
+		Map<String, List<CmdMap>> map = MaxSizeMap.getSynchronizedMap(5);
+
+		List<String> users = Arrays.asList("uid1", "uid2", "uid3", "uid4", "uid5", "uid6", "uid7", "uid8", "uid9", "uid10");
+		List<UserTestData> data = new ArrayList<>();
+		for (String u : users){
+			List<CmdMap> cmdm = new ArrayList<>();
+			cmdm.add(new CmdMap(u + ".anyCmd", new ArrayList<>(), Arrays.asList("all")));
+			data.add(new UserTestData(u, cmdm));
+		}
+		boolean success = ThreadManager.runTasks(3, (Object o) -> {
+			long slp = Math.round(Math.random() * 100);
+			try{ Thread.sleep(slp); } catch (Exception e) {}
+			UserTestData utd = (UserTestData) o;
+			map.put(utd.name, utd.map);
+			System.out.println(utd.name + " - " + slp); 		//DEBUG
+		}, data, 5000l);
+		
+		System.out.println("Success? " + success);
+		System.out.println(map.size());
+		System.out.println(map.keySet());
+		
+		map.put(data.get(0).name, data.get(0).map);
+		map.put(data.get(1).name, data.get(1).map);
+		System.out.println(map);
+	}
+
+}