Addition of AttackableThink and Movement task pools.

L2J_Mobius_01.0_Ertheia/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_01.0_Ertheia/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_01.0_Ertheia/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_02.5_Underground/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_02.5_Underground/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_02.5_Underground/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_03.0_Helios/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_03.0_Helios/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_03.0_Helios/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_04.0_GrandCrusade/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_04.0_GrandCrusade/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_04.0_GrandCrusade/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_05.0_Salvation/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_05.0_Salvation/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_05.0_Salvation/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_05.5_EtinasFate/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_05.5_EtinasFate/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_05.5_EtinasFate/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_06.0_Fafurion/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_06.0_Fafurion/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_06.0_Fafurion/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_07.0_PreludeOfWar/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_07.0_PreludeOfWar/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_07.0_PreludeOfWar/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_08.2_Homunculus/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_08.2_Homunculus/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_08.2_Homunculus/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_09.2_ReturnOfTheQueenAnt/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_09.2_ReturnOfTheQueenAnt/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_09.2_ReturnOfTheQueenAnt/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_10.2_MasterClass/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_10.2_MasterClass/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_10.2_MasterClass/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_10.3_MasterClass/java/org/l2jmobius/gameserver/Shutdown.java

@@ -48,7 +48,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -146,16 +145,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_10.3_MasterClass/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_10.3_MasterClass/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_C4_ScionsOfDestiny/java/org/l2jmobius/gameserver/Shutdown.java

@@ -47,7 +47,6 @@ import org.l2jmobius.gameserver.network.serverpackets.LeaveWorld;
 import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -296,16 +295,6 @@ public class Shutdown extends Thread
 		// saveData sends messages to exit players, so shutdown selector after it
 		saveData();
 		
-		try
-		{
-			MovementTaskManager.getInstance().interrupt();
-			LOGGER.info("Movement Task Manager thread has been shutdown.");
-		}
-		catch (Throwable t)
-		{
-			// ignore
-		}
-		
 		try
 		{
 			GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_C4_ScionsOfDestiny/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_C4_ScionsOfDestiny/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_C6_Interlude/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.LeaveWorld;
 import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -298,16 +297,6 @@ public class Shutdown extends Thread
 		// saveData sends messages to exit players, so shutdown selector after it
 		saveData();
 		
-		try
-		{
-			MovementTaskManager.getInstance().interrupt();
-			LOGGER.info("Movement Task Manager thread has been shutdown.");
-		}
-		catch (Throwable t)
-		{
-			// ignore
-		}
-		
 		try
 		{
 			GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_C6_Interlude/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_C6_Interlude/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_CT_0_Interlude/java/org/l2jmobius/gameserver/Shutdown.java

@@ -51,7 +51,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -149,16 +148,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_CT_0_Interlude/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_CT_0_Interlude/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_CT_2.4_Epilogue/java/org/l2jmobius/gameserver/Shutdown.java

@@ -53,7 +53,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -151,16 +150,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_CT_2.4_Epilogue/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_CT_2.4_Epilogue/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_CT_2.6_HighFive/java/org/l2jmobius/gameserver/Shutdown.java

@@ -53,7 +53,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -151,16 +150,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_CT_2.6_HighFive/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_CT_2.6_HighFive/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_1.5_AgeOfSplendor/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_1.5_AgeOfSplendor/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_1.5_AgeOfSplendor/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_2.0_Saviors/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_2.0_Saviors/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_2.0_Saviors/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_2.5_Zaken/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_2.5_Zaken/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_2.5_Zaken/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_2.7_Antharas/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_2.7_Antharas/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_2.7_Antharas/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_2.8_SevenSigns/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_2.8_SevenSigns/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_2.8_SevenSigns/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_2.9.5_Saviors/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_2.9.5_Saviors/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_2.9.5_Saviors/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_2.9_SecretOfEmpire/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_2.9_SecretOfEmpire/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_2.9_SecretOfEmpire/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_3.0_TheKamael/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_3.0_TheKamael/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_3.0_TheKamael/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Classic_Interlude/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Classic_Interlude/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Classic_Interlude/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Essence_4.2_DwellingOfSpirits/java/org/l2jmobius/gameserver/Shutdown.java

@@ -49,7 +49,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -147,16 +146,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Essence_4.2_DwellingOfSpirits/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Essence_4.2_DwellingOfSpirits/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Essence_5.2_FrostLord/java/org/l2jmobius/gameserver/Shutdown.java

@@ -50,7 +50,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -158,16 +157,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Essence_5.2_FrostLord/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Essence_5.2_FrostLord/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Essence_6.2_Vanguard/java/org/l2jmobius/gameserver/Shutdown.java

@@ -50,7 +50,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -158,16 +157,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Essence_6.2_Vanguard/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Essence_6.2_Vanguard/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()

L2J_Mobius_Essence_6.3_Crusader/java/org/l2jmobius/gameserver/Shutdown.java

@@ -50,7 +50,6 @@ import org.l2jmobius.gameserver.network.serverpackets.ServerClose;
 import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
 import org.l2jmobius.gameserver.network.telnet.TelnetServer;
 import org.l2jmobius.gameserver.taskmanager.GameTimeTaskManager;
-import org.l2jmobius.gameserver.taskmanager.MovementTaskManager;
 import org.l2jmobius.gameserver.util.Broadcast;
 
 /**
@@ -158,16 +157,6 @@ public class Shutdown extends Thread
 			
 			// ensure all services are stopped
 			
-			try
-			{
-				MovementTaskManager.getInstance().interrupt();
-				LOGGER.info("Movement Task Manager: Thread interruped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
-			}
-			catch (Throwable t)
-			{
-				// ignore
-			}
-			
 			try
 			{
 				GameTimeTaskManager.getInstance().interrupt();

L2J_Mobius_Essence_6.3_Crusader/java/org/l2jmobius/gameserver/taskmanager/AttackableThinkTaskManager.java

@@ -26,60 +26,85 @@ import org.l2jmobius.gameserver.model.actor.Attackable;
 /**
  * @author Mobius
  */
-public class AttackableThinkTaskManager implements Runnable
+public class AttackableThinkTaskManager
 {
-	private static final Set<Attackable> ATTACKABLES = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Attackable>> POOLS = ConcurrentHashMap.newKeySet();
-	private static boolean _working = false;
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 1000;
 	
 	protected AttackableThinkTaskManager()
 	{
-		ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
 	}
 	
-	@Override
+	private class AttackableThink implements Runnable
-	public void run()
 	{
-		if (_working)
+		private final Set<Attackable> _attackables;
-		{
-			return;
-		}
-		_working = true;
 		
-		CreatureAI ai;
+		public AttackableThink(Set<Attackable> attackables)
-		for (Attackable attackable : ATTACKABLES)
 		{
-			if (attackable.hasAI())
+			_attackables = attackables;
+		}
+		
+		@Override
+		public void run()
+		{
+			CreatureAI ai;
+			for (Attackable attackable : _attackables)
 			{
-				ai = attackable.getAI();
+				if (attackable.hasAI())
-				if (ai != null)
 				{
-					ai.onEvtThink();
+					ai = attackable.getAI();
+					if (ai != null)
+					{
+						ai.onEvtThink();
+					}
+					else
+					{
+						_attackables.remove(attackable);
+					}
 				}
 				else
 				{
-					remove(attackable);
+					_attackables.remove(attackable);
 				}
 			}
-			else
+		}
+	}
+	
+	public synchronized void add(Attackable attackable)
+	{
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.contains(attackable))
 			{
-				remove(attackable);
+				return;
 			}
 		}
 		
-		_working = false;
+		for (Set<Attackable> pool : POOLS)
-	}
-	
-	public void add(Attackable attackable)
-	{
-		if (!ATTACKABLES.contains(attackable))
 		{
-			ATTACKABLES.add(attackable);
+			if (pool.size() < POOL_SIZE)
+			{
+				pool.add(attackable);
+				return;
+			}
 		}
+		
+		final Set<Attackable> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(attackable);
+		ThreadPool.scheduleAtFixedRate(new AttackableThink(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public void remove(Attackable attackable)
 	{
-		ATTACKABLES.remove(attackable);
+		for (Set<Attackable> pool : POOLS)
+		{
+			if (pool.remove(attackable))
+			{
+				return;
+			}
+		}
 	}
 	
 	public static AttackableThinkTaskManager getInstance()

L2J_Mobius_Essence_6.3_Crusader/java/org/l2jmobius/gameserver/taskmanager/MovementTaskManager.java

@@ -19,53 +19,66 @@ package org.l2jmobius.gameserver.taskmanager;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.l2jmobius.commons.threads.ThreadPool;
 import org.l2jmobius.gameserver.model.actor.Creature;
 
 /**
  * Movement task manager class.
- * @author Forsaiken, Mobius
+ * @author Mobius
  */
-public class MovementTaskManager extends Thread
+public class MovementTaskManager
 {
-	private static final Set<Creature> MOVING_OBJECTS = ConcurrentHashMap.newKeySet();
+	private static final Set<Set<Creature>> POOLS = ConcurrentHashMap.newKeySet();
+	private static final int POOL_SIZE = 1000;
+	private static final int TASK_DELAY = 100;
 	
 	protected MovementTaskManager()
 	{
-		super("MovementTaskManager");
+	}
-		super.setDaemon(true);
+	
-		super.setPriority(MAX_PRIORITY);
+	private class Movement implements Runnable
-		super.start();
+	{
+		private final Set<Creature> _creatures;
+		
+		public Movement(Set<Creature> creatures)
+		{
+			_creatures = creatures;
+		}
+		
+		@Override
+		public void run()
+		{
+			_creatures.removeIf(Creature::updatePosition);
+		}
 	}
 	
 	/**
 	 * Add a Creature to moving objects of MovementTaskManager.
 	 * @param creature The Creature to add to moving objects of MovementTaskManager.
 	 */
-	public void registerMovingObject(Creature creature)
+	public synchronized void registerMovingObject(Creature creature)
 	{
-		if (creature == null)
+		for (Set<Creature> pool : POOLS)
 		{
-			return;
+			if (pool.contains(creature))
+			{
+				return;
+			}
 		}
 		
-		MOVING_OBJECTS.add(creature);
+		for (Set<Creature> pool : POOLS)
-	}
-	
-	@Override
-	public void run()
-	{
-		while (true)
 		{
-			try
+			if (pool.size() < POOL_SIZE)
 			{
-				MOVING_OBJECTS.removeIf(Creature::updatePosition);
+				pool.add(creature);
-				Thread.sleep(100);
+				return;
-			}
-			catch (InterruptedException e)
-			{
-				// Ignore.
 			}
 		}
+		
+		final Set<Creature> pool = ConcurrentHashMap.newKeySet(POOL_SIZE);
+		pool.add(creature);
+		ThreadPool.scheduleAtFixedRate(new Movement(pool), TASK_DELAY, TASK_DELAY);
+		POOLS.add(pool);
 	}
 	
 	public static final MovementTaskManager getInstance()