BETA: Dropping `L2HashMap` and using `ConcurrentHashMap` instead to benefit from new java 8 atomic operations.

	* Partial code clean up around `L2HashMap` uses.
	* `AntiFeedManager` cleaned up a bit.

Reviewed by: Zoey76, !UnAfraid

L2J_Server_BETA/java/com/l2jserver/gameserver/cache/HtmCache.java

@@ -21,13 +21,14 @@ package com.l2jserver.gameserver.cache;
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.util.Util;
-import com.l2jserver.util.L2FastMap;
 import com.l2jserver.util.file.filter.HTMLFilter;
 
 /**
@@ -39,7 +40,7 @@ public class HtmCache
 	
 	private static final HTMLFilter htmlFilter = new HTMLFilter();
 	
-	private static final Map<String, String> _cache = new L2FastMap<>(Config.LAZY_CACHE);
+	private static final Map<String, String> _cache = Config.LAZY_CACHE ? new ConcurrentHashMap<>() : new HashMap<>();
 	
 	private int _loadedFiles;
 	private long _bytesBuffLen;
@@ -122,7 +123,7 @@ public class HtmCache
 			content = new String(raw, "UTF-8");
 			content = content.replaceAll("(?s)<!--.*?-->", ""); // Remove html comments
 			
-			String oldContent = _cache.get(relpath);
+			String oldContent = _cache.put(relpath, content);
 			if (oldContent == null)
 			{
 				_bytesBuffLen += bytes;
@@ -132,7 +133,6 @@ public class HtmCache
 			{
 				_bytesBuffLen = (_bytesBuffLen - oldContent.length()) + bytes;
 			}
-			_cache.put(relpath, content);
 		}
 		catch (Exception e)
 		{

L2J_Server_BETA/java/com/l2jserver/gameserver/cache/WarehouseCacheManager.java

@@ -19,18 +19,18 @@
 package com.l2jserver.gameserver.cache;
 
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.ThreadPoolManager;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
-import com.l2jserver.util.L2FastMap;
 
 /**
  * @author -Nemesiss-
  */
 public class WarehouseCacheManager
 {
-	protected final Map<L2PcInstance, Long> _cachedWh = new L2FastMap<>(true);
+	protected final Map<L2PcInstance, Long> _cachedWh = new ConcurrentHashMap<>();
 	protected final long _cacheTime = Config.WAREHOUSE_CACHE_TIME * 60000L;
 	
 	protected WarehouseCacheManager()

L2J_Server_BETA/java/com/l2jserver/gameserver/datatables/CharNameTable.java

@@ -23,16 +23,15 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import com.l2jserver.Config;
 import com.l2jserver.L2DatabaseFactory;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
-import com.l2jserver.util.L2FastMap;
 
 /**
  * This class ...
@@ -42,8 +41,8 @@ public class CharNameTable
 {
 	private static Logger _log = Logger.getLogger(CharNameTable.class.getName());
 	
-	private final Map<Integer, String> _chars = new L2FastMap<>();
-	private final Map<Integer, Integer> _accessLevels = new L2FastMap<>();
+	private final Map<Integer, String> _chars = new ConcurrentHashMap<>();
+	private final Map<Integer, Integer> _accessLevels = new ConcurrentHashMap<>();
 	
 	protected CharNameTable()
 	{
@@ -86,15 +85,11 @@ public class CharNameTable
 			return -1;
 		}
 		
-		Iterator<Entry<Integer, String>> it = _chars.entrySet().iterator();
-		
-		Map.Entry<Integer, String> pair;
-		while (it.hasNext())
+		for (Entry<Integer, String> entry : _chars.entrySet())
 		{
-			pair = it.next();
-			if (pair.getValue().equalsIgnoreCase(name))
+			if (entry.getValue().equalsIgnoreCase(name))
 			{
-				return pair.getKey();
+				return entry.getKey();
 			}
 		}
 		
@@ -152,17 +147,18 @@ public class CharNameTable
 			return null;
 		}
 		
-		int accessLevel = 0;
 		try (Connection con = L2DatabaseFactory.getInstance().getConnection();
 			PreparedStatement ps = con.prepareStatement("SELECT char_name,accesslevel FROM characters WHERE charId=?"))
 		{
 			ps.setInt(1, id);
 			try (ResultSet rset = ps.executeQuery())
 			{
-				while (rset.next())
+				if (rset.next())
 				{
 					name = rset.getString(1);
-					accessLevel = rset.getInt(2);
+					_chars.put(id, name);
+					_accessLevels.put(id, rset.getInt(2));
+					return name;
 				}
 			}
 		}
@@ -171,13 +167,6 @@ public class CharNameTable
 			_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char id: " + e.getMessage(), e);
 		}
 		
-		if ((name != null) && !name.isEmpty())
-		{
-			_chars.put(id, name);
-			_accessLevels.put(id, accessLevel);
-			return name;
-		}
-		
 		return null; // not found
 	}
 	
@@ -210,9 +199,8 @@ public class CharNameTable
 		return result;
 	}
 	
-	public int accountCharNumber(String account)
+	public int getAccountCharacterCount(String account)
 	{
-		int number = 0;
 		try (Connection con = L2DatabaseFactory.getInstance().getConnection();
 			PreparedStatement ps = con.prepareStatement("SELECT COUNT(char_name) FROM characters WHERE account_name=?"))
 		{
@@ -221,33 +209,28 @@ public class CharNameTable
 			{
 				while (rset.next())
 				{
-					number = rset.getInt(1);
+					return rset.getInt(1);
 				}
 			}
 		}
 		catch (SQLException e)
 		{
-			_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char number: " + e.getMessage(), e);
+			_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char count: " + e.getMessage(), e);
 		}
-		return number;
+		return 0;
 	}
 	
 	private void loadAll()
 	{
-		String name;
-		int id = -1;
-		int accessLevel = 0;
 		try (Connection con = L2DatabaseFactory.getInstance().getConnection();
 			Statement s = con.createStatement();
-			ResultSet rs = s.executeQuery("SELECT charId,char_name,accesslevel FROM characters"))
+			ResultSet rs = s.executeQuery("SELECT charId, char_name, accesslevel FROM characters"))
 		{
 			while (rs.next())
 			{
-				id = rs.getInt(1);
-				name = rs.getString(2);
-				accessLevel = rs.getInt(3);
-				_chars.put(id, name);
-				_accessLevels.put(id, accessLevel);
+				final int id = rs.getInt(1);
+				_chars.put(id, rs.getString(2));
+				_accessLevels.put(id, rs.getInt(3));
 			}
 		}
 		catch (SQLException e)

L2J_Server_BETA/java/com/l2jserver/gameserver/instancemanager/AntiFeedManager.java

@@ -19,16 +19,13 @@
 package com.l2jserver.gameserver.instancemanager;
 
 import java.util.Map;
-
-import javolution.util.FastMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
-import com.l2jserver.gameserver.model.interfaces.IProcedure;
 import com.l2jserver.gameserver.network.L2GameClient;
-import com.l2jserver.util.L2FastMap;
-import com.l2jserver.util.L2HashMap;
 
 public final class AntiFeedManager
 {
@@ -37,8 +34,8 @@ public final class AntiFeedManager
 	public static final int TVT_ID = 2;
 	public static final int L2EVENT_ID = 3;
 	
-	private final Map<Integer, Long> _lastDeathTimes = new L2FastMap<>(true);
-	private final L2HashMap<Integer, Map<Integer, Connections>> _eventIPs = new L2HashMap<>();
+	private final Map<Integer, Long> _lastDeathTimes = new ConcurrentHashMap<>();
+	private final Map<Integer, Map<Integer, AtomicInteger>> _eventIPs = new ConcurrentHashMap<>();
 	
 	protected AntiFeedManager()
 	{
@@ -121,10 +118,7 @@ public final class AntiFeedManager
 	 */
 	public final void registerEvent(int eventId)
 	{
-		if (!_eventIPs.containsKey(eventId))
-		{
-			_eventIPs.put(eventId, new FastMap<Integer, Connections>());
-		}
+		_eventIPs.putIfAbsent(eventId, new ConcurrentHashMap<Integer, AtomicInteger>());
 	}
 	
 	/**
@@ -153,7 +147,7 @@ public final class AntiFeedManager
 			return false; // unable to determine IP address
 		}
 		
-		final Map<Integer, Connections> event = _eventIPs.get(eventId);
+		final Map<Integer, AtomicInteger> event = _eventIPs.get(eventId);
 		if (event == null)
 		{
 			return false; // no such event registered
@@ -166,18 +160,9 @@ public final class AntiFeedManager
 			limit += Config.L2JMOD_DUALBOX_CHECK_WHITELIST.get(addrHash);
 		}
 		
-		Connections conns;
-		synchronized (event)
-		{
-			conns = event.get(addrHash);
-			if (conns == null)
-			{
-				conns = new Connections();
-				event.put(addrHash, conns);
-			}
-		}
+		final AtomicInteger connectionCount = event.computeIfAbsent(addrHash, k -> new AtomicInteger());
 		
-		return conns.testAndIncrement(limit);
+		return connectionCount.getAndIncrement() < limit;
 	}
 	
 	/**
@@ -188,34 +173,38 @@ public final class AntiFeedManager
 	 */
 	public final boolean removePlayer(int eventId, L2PcInstance player)
 	{
-		final L2GameClient client = player.getClient();
+		return removeClient(eventId, player.getClient());
+	}
+	
+	/**
+	 * Decreasing number of active connection from player's IP address
+	 * @param eventId
+	 * @param client
+	 * @return true if success and false if any problem detected.
+	 */
+	public final boolean removeClient(int eventId, L2GameClient client)
+	{
 		if (client == null)
 		{
 			return false; // unable to determine IP address
 		}
 		
-		final Map<Integer, Connections> event = _eventIPs.get(eventId);
+		final Map<Integer, AtomicInteger> event = _eventIPs.get(eventId);
 		if (event == null)
 		{
 			return false; // no such event registered
 		}
 		
 		final Integer addrHash = Integer.valueOf(client.getConnectionAddress().hashCode());
-		Connections conns = event.get(addrHash);
-		if (conns == null)
-		{
-			return false; // address not registered
-		}
 		
-		synchronized (event)
+		return event.computeIfPresent(addrHash, (k, v) ->
 		{
-			if (conns.testAndDecrement())
+			if ((v == null) || (v.decrementAndGet() == 0))
 			{
-				event.remove(addrHash);
+				return null;
 			}
-		}
-		
-		return true;
+			return v;
+		}) != null;
 	}
 	
 	/**
@@ -229,8 +218,10 @@ public final class AntiFeedManager
 			return;
 		}
 		
-		final Integer addrHash = Integer.valueOf(client.getConnectionAddress().hashCode());
-		_eventIPs.executeForEachValue(new DisconnectProcedure(addrHash));
+		_eventIPs.forEach((k, v) ->
+		{
+			removeClient(k, client);
+		});
 	}
 	
 	/**
@@ -239,7 +230,7 @@ public final class AntiFeedManager
 	 */
 	public final void clear(int eventId)
 	{
-		final Map<Integer, Connections> event = _eventIPs.get(eventId);
+		final Map<Integer, AtomicInteger> event = _eventIPs.get(eventId);
 		if (event != null)
 		{
 			event.clear();
@@ -277,66 +268,6 @@ public final class AntiFeedManager
 		return limit;
 	}
 	
-	protected static final class Connections
-	{
-		private int _num = 0;
-		
-		/**
-		 * and false if maximum number is reached.
-		 * @param max
-		 * @return true if successfully incremented number of connections
-		 */
-		public final synchronized boolean testAndIncrement(int max)
-		{
-			if (_num < max)
-			{
-				_num++;
-				return true;
-			}
-			return false;
-		}
-		
-		/**
-		 * @return true if all connections are removed
-		 */
-		public final synchronized boolean testAndDecrement()
-		{
-			if (_num > 0)
-			{
-				_num--;
-			}
-			
-			return _num == 0;
-		}
-	}
-	
-	private static final class DisconnectProcedure implements IProcedure<Map<Integer, Connections>, Boolean>
-	{
-		private final Integer _addrHash;
-		
-		public DisconnectProcedure(Integer addrHash)
-		{
-			_addrHash = addrHash;
-		}
-		
-		@Override
-		public final Boolean execute(Map<Integer, Connections> event)
-		{
-			final Connections conns = event.get(_addrHash);
-			if (conns != null)
-			{
-				synchronized (event)
-				{
-					if (conns.testAndDecrement())
-					{
-						event.remove(_addrHash);
-					}
-				}
-			}
-			return true;
-		}
-	}
-	
 	public static final AntiFeedManager getInstance()
 	{
 		return SingletonHolder._instance;

L2J_Server_BETA/java/com/l2jserver/gameserver/instancemanager/MailManager.java

@@ -26,6 +26,7 @@ import java.sql.Statement;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -39,7 +40,6 @@ import com.l2jserver.gameserver.model.L2World;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.entity.Message;
 import com.l2jserver.gameserver.network.serverpackets.ExNoticePostArrived;
-import com.l2jserver.util.L2FastMap;
 
 /**
  * @author Migi, DS
@@ -48,7 +48,7 @@ public final class MailManager
 {
 	private static final Logger _log = Logger.getLogger(MailManager.class.getName());
 	
-	private final Map<Integer, Message> _messages = new L2FastMap<>(true);
+	private final Map<Integer, Message> _messages = new ConcurrentHashMap<>();
 	
 	protected MailManager()
 	{

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/knownlist/CharKnownList.java

@@ -23,6 +23,7 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import javolution.util.FastList;
 
@@ -31,7 +32,6 @@ import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Summon;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.util.Util;
-import com.l2jserver.util.L2FastMap;
 
 public class CharKnownList extends ObjectKnownList
 {
@@ -244,7 +244,7 @@ public class CharKnownList extends ObjectKnownList
 	{
 		if (_knownPlayers == null)
 		{
-			_knownPlayers = new L2FastMap<>(true);
+			_knownPlayers = new ConcurrentHashMap<>();
 		}
 		return _knownPlayers;
 	}
@@ -253,7 +253,7 @@ public class CharKnownList extends ObjectKnownList
 	{
 		if (_knownRelations == null)
 		{
-			_knownRelations = new L2FastMap<>(true);
+			_knownRelations = new ConcurrentHashMap<>();
 		}
 		return _knownRelations;
 	}
@@ -262,7 +262,7 @@ public class CharKnownList extends ObjectKnownList
 	{
 		if (_knownSummons == null)
 		{
-			_knownSummons = new L2FastMap<>(true);
+			_knownSummons = new ConcurrentHashMap<>();
 		}
 		return _knownSummons;
 	}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/knownlist/ObjectKnownList.java

@@ -21,13 +21,13 @@ package com.l2jserver.gameserver.model.actor.knownlist;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.L2WorldRegion;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Playable;
 import com.l2jserver.gameserver.util.Util;
-import com.l2jserver.util.L2FastMap;
 
 public class ObjectKnownList
 {
@@ -214,7 +214,7 @@ public class ObjectKnownList
 	{
 		if (_knownObjects == null)
 		{
-			_knownObjects = new L2FastMap<>(true);
+			_knownObjects = new ConcurrentHashMap<>();
 		}
 		return _knownObjects;
 	}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/entity/Instance.java

@@ -25,6 +25,7 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledFuture;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -65,7 +66,6 @@ import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
 import com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket;
 import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 import com.l2jserver.util.L2FastList;
-import com.l2jserver.util.L2FastMap;
 
 /**
  * Main class for game instances.
@@ -82,7 +82,7 @@ public final class Instance
 	private boolean _allowRandomWalk = true;
 	private final L2FastList<Integer> _players = new L2FastList<>(true);
 	private final List<L2Npc> _npcs = new L2FastList<>(true);
-	private final Map<Integer, L2DoorInstance> _doors = new L2FastMap<>(true);
+	private final Map<Integer, L2DoorInstance> _doors = new ConcurrentHashMap<>();
 	private final Map<String, List<L2Spawn>> _manualSpawn = new HashMap<>();
 	private Location _spawnLoc = null;
 	private boolean _allowSummon = true;

L2J_Server_BETA/java/com/l2jserver/gameserver/model/quest/Quest.java

@@ -27,6 +27,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
@@ -67,7 +68,6 @@ import com.l2jserver.gameserver.model.entity.Instance;
 import com.l2jserver.gameserver.model.holders.ItemHolder;
 import com.l2jserver.gameserver.model.interfaces.IIdentifiable;
 import com.l2jserver.gameserver.model.interfaces.IPositionable;
-import com.l2jserver.gameserver.model.interfaces.IProcedure;
 import com.l2jserver.gameserver.model.itemcontainer.Inventory;
 import com.l2jserver.gameserver.model.itemcontainer.PcInventory;
 import com.l2jserver.gameserver.model.items.L2Item;
@@ -92,7 +92,6 @@ import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 import com.l2jserver.gameserver.scripting.ManagedScript;
 import com.l2jserver.gameserver.scripting.ScriptManager;
 import com.l2jserver.gameserver.util.MinionList;
-import com.l2jserver.util.L2FastMap;
 import com.l2jserver.util.Rnd;
 import com.l2jserver.util.Util;
 
@@ -105,7 +104,7 @@ public class Quest extends ManagedScript implements IIdentifiable
 	public static final Logger _log = Logger.getLogger(Quest.class.getName());
 	
 	/** Map containing lists of timers from the name of the timer. */
-	private final Map<String, List<QuestTimer>> _allEventTimers = new L2FastMap<>(true);
+	private final Map<String, List<QuestTimer>> _allEventTimers = new ConcurrentHashMap<>();
 	private final Set<Integer> _questInvolvedNpcs = new HashSet<>();
 	
 	private final ReentrantReadWriteLock _rwLock = new ReentrantReadWriteLock();
@@ -279,30 +278,19 @@ public class Quest extends ManagedScript implements IIdentifiable
 	 */
 	public void startQuestTimer(String name, long time, L2Npc npc, L2PcInstance player, boolean repeating)
 	{
-		List<QuestTimer> timers = _allEventTimers.get(name);
-		// Add quest timer if timer doesn't already exist
-		if (timers == null)
+		final List<QuestTimer> timers = _allEventTimers.computeIfAbsent(name, k -> new ArrayList<>());
+		// if there exists a timer with this name, allow the timer only if the [npc, player] set is unique
+		// nulls act as wildcards
+		if (getQuestTimer(name, npc, player) == null)
 		{
-			timers = new ArrayList<>();
-			timers.add(new QuestTimer(this, name, time, npc, player, repeating));
-			_allEventTimers.put(name, timers);
-		}
-		// a timer with this name exists, but may not be for the same set of npc and player
-		else
-		{
-			// if there exists a timer with this name, allow the timer only if the [npc, player] set is unique
-			// nulls act as wildcards
-			if (getQuestTimer(name, npc, player) == null)
+			_writeLock.lock();
+			try
 			{
-				_writeLock.lock();
-				try
-				{
-					timers.add(new QuestTimer(this, name, time, npc, player, repeating));
-				}
-				finally
-				{
-					_writeLock.unlock();
-				}
+				timers.add(new QuestTimer(this, name, time, npc, player, repeating));
+			}
+			finally
+			{
+				_writeLock.unlock();
 			}
 		}
 	}
@@ -3780,26 +3768,18 @@ public class Quest extends ManagedScript implements IIdentifiable
 		{
 			if (includeCommandChannel && player.getParty().isInCommandChannel())
 			{
-				player.getParty().getCommandChannel().forEachMember(new IProcedure<L2PcInstance, Boolean>()
+				player.getParty().getCommandChannel().forEachMember(member ->
 				{
-					@Override
-					public Boolean execute(L2PcInstance member)
-					{
-						actionForEachPlayer(member, npc, isSummon);
-						return true;
-					}
+					actionForEachPlayer(member, npc, isSummon);
+					return true;
 				});
 			}
 			else if (includeParty)
 			{
-				player.getParty().forEachMember(new IProcedure<L2PcInstance, Boolean>()
+				player.getParty().forEachMember(member ->
 				{
-					@Override
-					public Boolean execute(L2PcInstance member)
-					{
-						actionForEachPlayer(member, npc, isSummon);
-						return true;
-					}
+					actionForEachPlayer(member, npc, isSummon);
+					return true;
 				});
 			}
 		}

L2J_Server_BETA/java/com/l2jserver/gameserver/network/clientpackets/CharacterCreate.java

@@ -167,7 +167,7 @@ public final class CharacterCreate extends L2GameClientPacket
 		 */
 		synchronized (CharNameTable.getInstance())
 		{
-			if ((CharNameTable.getInstance().accountCharNumber(getClient().getAccountName()) >= Config.MAX_CHARACTERS_NUMBER_PER_ACCOUNT) && (Config.MAX_CHARACTERS_NUMBER_PER_ACCOUNT != 0))
+			if ((CharNameTable.getInstance().getAccountCharacterCount(getClient().getAccountName()) >= Config.MAX_CHARACTERS_NUMBER_PER_ACCOUNT) && (Config.MAX_CHARACTERS_NUMBER_PER_ACCOUNT != 0))
 			{
 				if (Config.DEBUG)
 				{

L2J_Server_BETA/java/com/l2jserver/gameserver/taskmanager/TaskManager.java

@@ -31,6 +31,7 @@ import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledFuture;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -51,7 +52,6 @@ import com.l2jserver.gameserver.taskmanager.tasks.TaskScript;
 import com.l2jserver.gameserver.taskmanager.tasks.TaskSevenSignsUpdate;
 import com.l2jserver.gameserver.taskmanager.tasks.TaskShutdown;
 import com.l2jserver.util.L2FastList;
-import com.l2jserver.util.L2FastMap;
 
 /**
  * @author Layane
@@ -60,7 +60,7 @@ public final class TaskManager
 {
 	protected static final Logger _log = Logger.getLogger(TaskManager.class.getName());
 	
-	private final Map<Integer, Task> _tasks = new L2FastMap<>(true);
+	private final Map<Integer, Task> _tasks = new ConcurrentHashMap<>();
 	protected final List<ExecutedTask> _currentTasks = new L2FastList<>(true);
 	
 	protected static final String[] SQL_STATEMENTS =
@@ -203,11 +203,11 @@ public final class TaskManager
 	public void registerTask(Task task)
 	{
 		int key = task.getName().hashCode();
-		if (!_tasks.containsKey(key))
+		_tasks.computeIfAbsent(key, k ->
 		{
-			_tasks.put(key, task);
 			task.initializate();
-		}
+			return task;
+		});
 	}
 	
 	private void startAllTasks()

L2J_Server_BETA/java/com/l2jserver/util/L2FastMap.java

@@ -1,130 +0,0 @@
-/*
- * Copyright (C) 2004-2014 L2J Server
- * 
- * This file is part of L2J Server.
- * 
- * L2J Server is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * 
- * L2J Server is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.l2jserver.util;
-
-import java.util.Map;
-
-import javolution.util.FastMap;
-
-import com.l2jserver.gameserver.model.interfaces.IL2EntryProcedure;
-import com.l2jserver.gameserver.model.interfaces.IProcedure;
-
-/**
- * A custom version of FastMap with extension for iterating without using temporary collection<br>
- * It's provide synchronization lock when iterating if needed<br>
- * @author Julian
- * @version 1.0.1 (2008-02-07)<br>
- *          Changes:<br>
- *          1.0.0 - Initial version.<br>
- *          1.0.1 - Made forEachP() final.<br>
- * @author UnAfraid
- * @version 1.0.2 (2012-08-19)<br>
- *          1.0.2 - Using IL2Procedure instead of I2ForEachKey/Value<br>
- * @param <K>
- * @param <V>
- */
-public class L2FastMap<K, V> extends FastMap<K, V>
-{
-	private static final long serialVersionUID = 8503855490858805336L;
-	
-	public L2FastMap()
-	{
-		this(false);
-	}
-	
-	public L2FastMap(Map<? extends K, ? extends V> map)
-	{
-		this(map, false);
-	}
-	
-	public L2FastMap(int initialCapacity)
-	{
-		this(initialCapacity, false);
-	}
-	
-	public L2FastMap(boolean shared)
-	{
-		super();
-		if (shared)
-		{
-			shared();
-		}
-	}
-	
-	public L2FastMap(Map<? extends K, ? extends V> map, boolean shared)
-	{
-		super(map);
-		if (shared)
-		{
-			shared();
-		}
-	}
-	
-	public L2FastMap(int initialCapacity, boolean shared)
-	{
-		super(initialCapacity);
-		if (shared)
-		{
-			shared();
-		}
-	}
-	
-	/**
-	 * Public method that iterate entire collection.<br>
-	 * <br>
-	 * @param proc - a class method that must be executed on every element of collection.<br>
-	 * @return - returns true if entire collection is iterated, false if it`s been interrupted by<br>
-	 *         check method (IL2EntryProcedure.execute())<br>
-	 */
-	public boolean executeForEachEntry(IL2EntryProcedure<K, V> proc)
-	{
-		for (Map.Entry<K, V> e : entrySet())
-		{
-			if (!proc.execute(e.getKey(), e.getValue()))
-			{
-				return false;
-			}
-		}
-		return true;
-	}
-	
-	public boolean executeForEachKey(IProcedure<K, Boolean> proc)
-	{
-		for (K k : keySet())
-		{
-			if (!proc.execute(k))
-			{
-				return false;
-			}
-		}
-		return true;
-	}
-	
-	public boolean executeForEachValue(IProcedure<V, Boolean> proc)
-	{
-		for (V v : values())
-		{
-			if (!proc.execute(v))
-			{
-				return false;
-			}
-		}
-		return true;
-	}
-}

L2J_Server_BETA/java/com/l2jserver/util/L2HashMap.java

@@ -26,8 +26,6 @@ import com.l2jserver.gameserver.model.interfaces.IProcedure;
 
 /**
  * A custom version of HashMap: Extension for iterating without using temporary collection<br>
- * Note that this implementation is not synchronized. If multiple threads access a hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the
- * map. If no such object exists, the map should be "wrapped" using the {@link L2FastMap}. This is best done at creation time, to prevent accidental unsynchronized access.
  * @author UnAfraid
  * @param <K>
  * @param <V>