Refractor Locker -> fix one concurent exception on HashMap + clean the code

src/dev/peerat/framework/Client.java

@@ -29,20 +29,20 @@ public class Client<U extends User> extends Thread{
 			writer.flush();
 			writer.close();
 		}catch(AuthException e){
-			this.router.getExceptionLogger().setValue(e);
+			this.router.getExceptionLogger().pushValue(e);
 		}catch(Throwable e){
-			this.router.getExceptionLogger().setValue(e);
+			this.router.getExceptionLogger().pushValue(e);
 			if(context != null && context.getResponseCode() == 0){
 				try{
 					context.response(500);
 					writer.flush();
 					writer.close();
 				}catch(Exception ex){
-					this.router.getExceptionLogger().setValue(ex);
+					this.router.getExceptionLogger().pushValue(ex);
 				}
 			}
 		}
-		if(context != null) router.getLogger().setValue(context);
+		if(context != null) router.getLogger().pushValue(context);
 	}
 
 	private User isLogin(RequestType type, HttpReader reader) throws AuthException{
@@ -54,7 +54,7 @@ public class Client<U extends User> extends Thread{
 				writer.flush();
 				writer.close();
 			}catch(Exception ex){
-				this.router.getExceptionLogger().setValue(ex);
+				this.router.getExceptionLogger().pushValue(ex);
 			}
 			throw new AuthException(e);
 		}

src/dev/peerat/framework/Locker.java

@@ -1,9 +1,8 @@
 package dev.peerat.framework;
 
-import java.util.HashMap;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -13,7 +12,7 @@ public class Locker<V>{
 	private Map<Key, BlockingQueue<V>> map;
 	
 	public Locker(){
-		this.map = new HashMap<>();
+		this.map = new ConcurrentHashMap<>();
 	}
 	
 	public void init(Key key){
@@ -28,21 +27,20 @@ public class Locker<V>{
 		return this.map.get(key);
 	}
 	
-	public void setValue(V value){
+	public void pushValue(V value){
-		for(Entry<Key, BlockingQueue<V>> entry : this.map.entrySet()){
+		for(BlockingQueue<V> queue : this.map.values()){
-			entry.getValue().add(value);
+			queue.add(value);
-			this.unlock(entry.getKey());
+			unlock(queue);
 		}
 	}
 	
-	public V getValue(Key key){
+	public V getValue(Key key) throws InterruptedException{
 		BlockingQueue<V> queue = get(key);
-		if(queue.isEmpty()) return null;
+		lock(queue);
 		return queue.poll();
 	}
 
-	public void lock(Key key) throws InterruptedException{
+	private void lock(BlockingQueue<V> queue) throws InterruptedException{
-		BlockingQueue<V> queue = get(key);
 		if(queue.isEmpty()){
 			synchronized(queue){
 				queue.wait();
@@ -50,8 +48,7 @@ public class Locker<V>{
 		}
 	}
 	
-	public void unlock(Key key){
+	private void unlock(BlockingQueue<V> queue){
-		BlockingQueue<V> queue = get(key);
 		synchronized(queue){
 			queue.notify();
 		}
@@ -61,46 +58,40 @@ public class Locker<V>{
 		Key key = new Key();
 		init(key);
 		try {
-			while(true){
+			while(true) action.accept(getValue(key));
-				lock(key);
-				V value = getValue(key);
-				action.accept(value);
-			}
 		}catch(Exception e){}
 		remove(key);
 	}
 	
+	public void listen(Consumer<V> action, Consumer<Exception> onClose){
+		Key key = new Key();
+		init(key);
+		try {
+			while(true) action.accept(getValue(key));
+		}catch(Exception e){
+			onClose.accept(e);
+		}
+		remove(key);
+	}
+	
 	public void listen(Supplier<Boolean> condition, Consumer<V> action){
 		Key key = new Key();
 		init(key);
 		try {
-			while(condition.get()){
+			while(condition.get()) action.accept(getValue(key));
-				lock(key);
-				V value = getValue(key);
-				action.accept(value);
-			}
 		}catch(Exception e){}
 		remove(key);
 	}
 	
-	public Thread listenAsync(Consumer<V> action){
+	public void listen(Supplier<Boolean> condition, Consumer<V> action, Consumer<Exception> onClose){
-		Thread thread = new Thread(new Runnable(){
+		Key key = new Key();
-			public void run(){
+		init(key);
-				listen(action);
+		try {
+			while(condition.get()) action.accept(getValue(key));
+		}catch(Exception e){
+			onClose.accept(e);
 		}
-		});
+		remove(key);
-		thread.start();
-		return thread;
-	}
-	
-	public Thread listenAsync(Supplier<Boolean> condition,Consumer<V> action){
-		Thread thread = new Thread(new Runnable(){
-			public void run(){
-				listen(condition, action);
-			}
-		});
-		thread.start();
-		return thread;
 	}
 	
 	public static class Key{ public Key(){} }