API tools faq
paste
Advertisement
Nik

L2World trove + reentrant lock

Nik
Aug 3rd, 2011
327
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 39.50 KB | None | 0 0
raw download clone embed print report
  1. Index: java/com/l2jserver/gameserver/LoginServerThread.java
  2. ===================================================================
  3. --- java/com/l2jserver/gameserver/LoginServerThread.java    (revision 4790)
  4. +++ java/com/l2jserver/gameserver/LoginServerThread.java    (working copy)
  5. @@ -32,7 +32,6 @@
  6.  import java.sql.ResultSet;
  7.  import java.sql.SQLException;
  8.  import java.util.ArrayList;
  9. -import java.util.Collection;
  10.  import java.util.List;
  11.  import java.util.Map;
  12.  import java.util.logging.Level;
  13. @@ -292,10 +291,9 @@
  14.                             if (L2World.getInstance().getAllPlayersCount() > 0)
  15.                             {
  16.                                 FastList<String> playerList = new FastList<String>();
  17. -                               Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  18.                                 //synchronized (L2World.getInstance().getAllPlayers())
  19.                                 {
  20. -                                   for (L2PcInstance player : pls)
  21. +                                   for (L2PcInstance player : L2World.getInstance().getAllPlayersArray())
  22.                                         playerList.add(player.getAccountName());
  23.                                 }
  24.                                 PlayerInGame pig = new PlayerInGame(playerList);
  25. Index: java/com/l2jserver/gameserver/SevenSigns.java
  26. ===================================================================
  27. --- java/com/l2jserver/gameserver/SevenSigns.java   (revision 4790)
  28. +++ java/com/l2jserver/gameserver/SevenSigns.java   (working copy)
  29. @@ -14,12 +14,13 @@
  30.   */
  31.  package com.l2jserver.gameserver;
  32.  
  33. +import gnu.trove.TObjectProcedure;
  34. +
  35.  import java.sql.Connection;
  36.  import java.sql.PreparedStatement;
  37.  import java.sql.ResultSet;
  38.  import java.sql.SQLException;
  39.  import java.util.Calendar;
  40. -import java.util.Collection;
  41.  import java.util.List;
  42.  import java.util.Map;
  43.  import java.util.logging.Level;
  44. @@ -1383,20 +1384,28 @@
  45.      */
  46.     protected void teleLosingCabalFromDungeons(String compWinner)
  47.     {
  48. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  49. -       //synchronized (L2World.getInstance().getAllPlayers())
  50. +       L2World.getInstance().forEachPlayer(new teleLosingCabalFromDungeons(compWinner));
  51. +   }
  52. +  
  53. +   private final class teleLosingCabalFromDungeons implements TObjectProcedure<L2PcInstance>
  54. +   {
  55. +       private final String _cmpWinner;
  56. +      
  57. +       private teleLosingCabalFromDungeons(final String compWinner)
  58. +       {
  59. +           _cmpWinner = compWinner;
  60. +       }
  61. +      
  62. +       @Override
  63. +       public final boolean execute(final L2PcInstance onlinePlayer)
  64.         {
  65. -           StatsSet currPlayer;
  66. -           for (L2PcInstance onlinePlayer : pls)
  67. +           if (onlinePlayer != null)
  68.             {
  69. -               if (onlinePlayer == null)
  70. -                   continue;
  71. -              
  72. -               currPlayer = _signsPlayerData.get(onlinePlayer.getObjectId());
  73. +               StatsSet currPlayer = _signsPlayerData.get(onlinePlayer.getObjectId());
  74.                
  75.                 if (isSealValidationPeriod() || isCompResultsPeriod())
  76.                 {
  77. -                   if (!onlinePlayer.isGM() && onlinePlayer.isIn7sDungeon() && (currPlayer == null || !currPlayer.getString("cabal").equals(compWinner)))
  78. +                   if (!onlinePlayer.isGM() && onlinePlayer.isIn7sDungeon() && (currPlayer == null || !currPlayer.getString("cabal").equals(_cmpWinner)))
  79.                     {
  80.                         onlinePlayer.teleToLocation(MapRegionManager.TeleportWhereType.Town);
  81.                         onlinePlayer.setIsIn7sDungeon(false);
  82. @@ -1413,6 +1422,8 @@
  83.                     }
  84.                 }
  85.             }
  86. +          
  87. +           return true;
  88.         }
  89.     }
  90.    
  91. @@ -1574,33 +1585,53 @@
  92.    
  93.     public void giveCPMult(int StrifeOwner)
  94.     {
  95. -       int cabal;
  96. -       //Gives "Victor of War" passive skill to all online characters with Cabal, which controls Seal of Strife
  97. -       for (L2PcInstance character : L2World.getInstance().getAllPlayers().values())
  98. +       L2World.getInstance().forEachPlayer(new giveCPMult(StrifeOwner));
  99. +   }
  100. +  
  101. +   private final class giveCPMult implements TObjectProcedure<L2PcInstance>
  102. +   {
  103. +       private final int _strifeOwner;
  104. +      
  105. +       private giveCPMult(int strifeOwner)
  106. +       {
  107. +           _strifeOwner = strifeOwner;
  108. +       }
  109. +       @Override
  110. +       public final boolean execute(final L2PcInstance character)
  111.         {
  112. -           if (character == null)
  113. -               continue;
  114. +           if (character != null)
  115. +           {
  116. +               //Gives "Victor of War" passive skill to all online characters with Cabal, which controls Seal of Strife
  117. +               int cabal = getPlayerCabal(character.getObjectId());
  118. +               if (cabal != SevenSigns.CABAL_NULL)
  119. +                   if (cabal == _strifeOwner)
  120. +                       character.addSkill(SkillTable.FrequentSkill.THE_VICTOR_OF_WAR.getSkill());
  121. +                   else
  122. +                       //Gives "The Vanquished of War" passive skill to all online characters with Cabal, which does not control Seal of Strife
  123. +                       character.addSkill(SkillTable.FrequentSkill.THE_VANQUISHED_OF_WAR.getSkill());
  124. +           }
  125.            
  126. -           cabal = getPlayerCabal(character.getObjectId());
  127. -           if (cabal != SevenSigns.CABAL_NULL)
  128. -               if (cabal == StrifeOwner)
  129. -                   character.addSkill(SkillTable.FrequentSkill.THE_VICTOR_OF_WAR.getSkill());
  130. -               else
  131. -                   //Gives "The Vanquished of War" passive skill to all online characters with Cabal, which does not control Seal of Strife
  132. -                   character.addSkill(SkillTable.FrequentSkill.THE_VANQUISHED_OF_WAR.getSkill());
  133. +           return true;
  134.         }
  135.     }
  136.    
  137.     public void removeCPMult()
  138.     {
  139. -       for (L2PcInstance character : L2World.getInstance().getAllPlayers().values())
  140. +       L2World.getInstance().forEachPlayer(new removeCPMult());
  141. +   }
  142. +  
  143. +   private final class removeCPMult implements TObjectProcedure<L2PcInstance>
  144. +   {  
  145. +       @Override
  146. +       public final boolean execute(final L2PcInstance character)
  147.         {
  148. -           if (character == null)
  149. -               continue;
  150. -          
  151. -           //Remove SevenSigns' buffs/debuffs.
  152. -           character.removeSkill(SkillTable.FrequentSkill.THE_VICTOR_OF_WAR.getSkill());
  153. -           character.removeSkill(SkillTable.FrequentSkill.THE_VANQUISHED_OF_WAR.getSkill());
  154. +           if (character != null)
  155. +           {
  156. +               //Remove SevenSigns' buffs/debuffs.
  157. +               character.removeSkill(SkillTable.FrequentSkill.THE_VICTOR_OF_WAR.getSkill());
  158. +               character.removeSkill(SkillTable.FrequentSkill.THE_VANQUISHED_OF_WAR.getSkill());
  159. +           }
  160. +           return true;
  161.         }
  162.     }
  163.    
  164. Index: java/com/l2jserver/gameserver/SevenSignsFestival.java
  165. ===================================================================
  166. --- java/com/l2jserver/gameserver/SevenSignsFestival.java   (revision 4790)
  167. +++ java/com/l2jserver/gameserver/SevenSignsFestival.java   (working copy)
  168. @@ -14,12 +14,13 @@
  169.   */
  170.  package com.l2jserver.gameserver;
  171.  
  172. +import gnu.trove.TObjectProcedure;
  173. +
  174.  import java.sql.Connection;
  175.  import java.sql.PreparedStatement;
  176.  import java.sql.ResultSet;
  177.  import java.sql.SQLException;
  178.  import java.util.ArrayList;
  179. -import java.util.Collection;
  180.  import java.util.List;
  181.  import java.util.Map;
  182.  import java.util.concurrent.ScheduledFuture;
  183. @@ -1251,23 +1252,7 @@
  184.         saveFestivalData(updateSettings);
  185.        
  186.         // Remove any unused blood offerings from online players.
  187. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  188. -       //synchronized (L2World.getInstance().getAllPlayers())
  189. -       {
  190. -           for (L2PcInstance onlinePlayer : pls)
  191. -           {
  192. -               try
  193. -               {
  194. -                   L2ItemInstance bloodOfferings = onlinePlayer.getInventory().getItemByItemId(FESTIVAL_OFFERING_ID);
  195. -                  
  196. -                   if (bloodOfferings != null)
  197. -                       onlinePlayer.destroyItem("SevenSigns", bloodOfferings, null, false);
  198. -               }
  199. -               catch (NullPointerException e)
  200. -               {
  201. -               }
  202. -           }
  203. -       }
  204. +       L2World.getInstance().forEachPlayer(new ForEachPlayerRemoveUnusedBloodOfferings());
  205.        
  206.         _log.info("SevenSignsFestival: Reinitialized engine for next competition period.");
  207.     }
  208. @@ -2450,6 +2435,25 @@
  209.         }
  210.     }
  211.    
  212. +   private final class ForEachPlayerRemoveUnusedBloodOfferings implements TObjectProcedure<L2PcInstance>
  213. +   {  
  214. +       @Override
  215. +       public final boolean execute(final L2PcInstance onlinePlayer)
  216. +       {
  217. +           try
  218. +           {
  219. +               L2ItemInstance bloodOfferings = onlinePlayer.getInventory().getItemByItemId(FESTIVAL_OFFERING_ID);
  220. +              
  221. +               if (bloodOfferings != null)
  222. +                   onlinePlayer.destroyItem("SevenSigns", bloodOfferings, null, false);
  223. +           }
  224. +           catch (NullPointerException e)
  225. +           {
  226. +           }
  227. +           return true;
  228. +       }
  229. +   }
  230. +  
  231.     @SuppressWarnings("synthetic-access")
  232.     private static class SingletonHolder
  233.     {
  234. Index: java/com/l2jserver/gameserver/Shutdown.java
  235. ===================================================================
  236. --- java/com/l2jserver/gameserver/Shutdown.java (revision 4790)
  237. +++ java/com/l2jserver/gameserver/Shutdown.java (working copy)
  238. @@ -14,7 +14,8 @@
  239.   */
  240.  package com.l2jserver.gameserver;
  241.  
  242. -import java.util.Collection;
  243. +import gnu.trove.TObjectProcedure;
  244. +
  245.  import java.util.logging.Level;
  246.  import java.util.logging.Logger;
  247.  
  248. @@ -576,13 +577,16 @@
  249.      */
  250.     private void disconnectAllCharacters()
  251.     {
  252. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  253. -       //synchronized (L2World.getInstance().getAllPlayers())
  254. +       L2World.getInstance().forEachPlayer(new disconnectAllCharacters());
  255. +   }
  256. +  
  257. +   private final class disconnectAllCharacters implements TObjectProcedure<L2PcInstance>
  258. +   {
  259. +       @Override
  260. +       public final boolean execute(final L2PcInstance player)
  261.         {
  262. -           for (L2PcInstance player : pls)
  263. +           if (player != null)
  264.             {
  265. -               if (player == null)
  266. -                   continue;
  267.                 //Logout Character
  268.                 try
  269.                 {
  270. @@ -597,9 +601,10 @@
  271.                 }
  272.                 catch (Throwable t)
  273.                 {
  274. -                   _log.log(Level.WARNING, "Failed logour char "+player, t);
  275. +                   _log.log(Level.WARNING, "Failed logour char " + player, t);
  276.                 }
  277.             }
  278. +           return true;
  279.         }
  280.     }
  281.    
  282. Index: java/com/l2jserver/gameserver/communitybbs/Manager/RegionBBSManager.java
  283. ===================================================================
  284. --- java/com/l2jserver/gameserver/communitybbs/Manager/RegionBBSManager.java    (revision 4790)
  285. +++ java/com/l2jserver/gameserver/communitybbs/Manager/RegionBBSManager.java    (working copy)
  286. @@ -272,12 +272,11 @@
  287.         return SingletonHolder._instance;
  288.     }
  289.    
  290. -   public /*synchronized */ void changeCommunityBoard()
  291. +   public/*synchronized */void changeCommunityBoard()
  292.     {
  293.         FastList<L2PcInstance> sortedPlayers = new FastList<L2PcInstance>();
  294. -       sortedPlayers.addAll(L2World.getInstance().getAllPlayers().values());
  295. -      
  296. -       Collections.sort(sortedPlayers, new Comparator<L2PcInstance>()
  297. +       Collections.addAll(sortedPlayers, L2World.getInstance().getAllPlayersArray());
  298. +       Collections.sort(sortedPlayers, new Comparator<L2PcInstance>()
  299.         {
  300.             @Override
  301.             public int compare(L2PcInstance p1, L2PcInstance p2)
  302. @@ -298,7 +297,7 @@
  303.         _communityPages.clear();
  304.         writeCommunityPages();
  305.     }
  306. -  
  307. +
  308.     private void addOnlinePlayer(L2PcInstance player)
  309.     {
  310.         boolean added = false;
  311. Index: java/com/l2jserver/gameserver/datatables/OfflineTradersTable.java
  312. ===================================================================
  313. --- java/com/l2jserver/gameserver/datatables/OfflineTradersTable.java   (revision 4790)
  314. +++ java/com/l2jserver/gameserver/datatables/OfflineTradersTable.java   (working copy)
  315. @@ -62,7 +62,7 @@
  316.             PreparedStatement stm_items = con.prepareStatement(SAVE_ITEMS);
  317.            
  318.             //TextBuilder items = TextBuilder.newInstance();
  319. -           for (L2PcInstance pc : L2World.getInstance().getAllPlayers().values())
  320. +           for (L2PcInstance pc : L2World.getInstance().getAllPlayersArray())
  321.             {
  322.                 try
  323.                 {
  324. Index: java/com/l2jserver/gameserver/instancemanager/BoatManager.java
  325. ===================================================================
  326. --- java/com/l2jserver/gameserver/instancemanager/BoatManager.java  (revision 4790)
  327. +++ java/com/l2jserver/gameserver/instancemanager/BoatManager.java  (working copy)
  328. @@ -14,7 +14,8 @@
  329.   */
  330.  package com.l2jserver.gameserver.instancemanager;
  331.  
  332. -import java.util.Collection;
  333. +import gnu.trove.TObjectProcedure;
  334. +
  335.  import java.util.Map;
  336.  
  337.  import javolution.util.FastMap;
  338. @@ -152,25 +153,8 @@
  339.      */
  340.     public void broadcastPacket(VehiclePathPoint point1, VehiclePathPoint point2, L2GameServerPacket packet)
  341.     {
  342. -       double dx, dy;
  343. -       final Collection<L2PcInstance> players = L2World.getInstance().getAllPlayers().values();
  344. -       for (L2PcInstance player : players)
  345. -       {
  346. -           if (player == null)
  347. -               continue;
  348. -          
  349. -           dx = (double)player.getX() - point1.x;
  350. -           dy = (double)player.getY() - point1.y;
  351. -           if (Math.sqrt(dx*dx + dy*dy) < Config.BOAT_BROADCAST_RADIUS)
  352. -               player.sendPacket(packet);
  353. -           else
  354. -           {
  355. -               dx = (double)player.getX() - point2.x;
  356. -               dy = (double)player.getY() - point2.y;
  357. -               if (Math.sqrt(dx*dx + dy*dy) < Config.BOAT_BROADCAST_RADIUS)
  358. -                   player.sendPacket(packet);
  359. -           }
  360. -       }
  361. +      
  362. +       L2World.getInstance().forEachPlayer(new ForEachPlayerBroadcastPackets(point1, point2, packet));
  363.     }
  364.    
  365.     /**
  366. @@ -178,27 +162,46 @@
  367.      */
  368.     public void broadcastPackets(VehiclePathPoint point1, VehiclePathPoint point2, L2GameServerPacket... packets)
  369.     {
  370. -       double dx, dy;
  371. -       final Collection<L2PcInstance> players = L2World.getInstance().getAllPlayers().values();
  372. -       for (L2PcInstance player : players)
  373. +       L2World.getInstance().forEachPlayer(new ForEachPlayerBroadcastPackets(point1, point2, packets));
  374. +   }
  375. +  
  376. +   private final class ForEachPlayerBroadcastPackets implements TObjectProcedure<L2PcInstance>
  377. +   {
  378. +       VehiclePathPoint _point1, _point2;
  379. +       L2GameServerPacket[] _packets;
  380. +      
  381. +       private ForEachPlayerBroadcastPackets(VehiclePathPoint point1, VehiclePathPoint point2, L2GameServerPacket ... packets)
  382.         {
  383. -           if (player == null)
  384. -               continue;
  385. -           dx = (double)player.getX() - point1.x;
  386. -           dy = (double)player.getY() - point1.y;
  387. -           if (Math.sqrt(dx*dx + dy*dy) < Config.BOAT_BROADCAST_RADIUS)
  388. -           {
  389. -               for (L2GameServerPacket p : packets)
  390. -                   player.sendPacket(p);
  391. -           }
  392. -           else
  393. +           _point1 = point1;
  394. +           _point2 = point2;
  395. +           _packets = packets;
  396. +       }
  397. +      
  398. +       @Override
  399. +       public final boolean execute(final L2PcInstance player)
  400. +       {
  401. +           if (player != null)
  402.             {
  403. -               dx = (double)player.getX() - point2.x;
  404. -               dy = (double)player.getY() - point2.y;
  405. -               if (Math.sqrt(dx*dx + dy*dy) < Config.BOAT_BROADCAST_RADIUS)
  406. -                   for (L2GameServerPacket p : packets)
  407. +               double dx = (double) player.getX() - _point1.x;
  408. +               double dy = (double) player.getY() - _point1.y;
  409. +               if (Math.sqrt(dx * dx + dy * dy) < Config.BOAT_BROADCAST_RADIUS)
  410. +               {
  411. +                   for (L2GameServerPacket p : _packets)
  412.                         player.sendPacket(p);
  413. +               }
  414. +               else
  415. +               {
  416. +                   dx = (double) player.getX() - _point2.x;
  417. +                   dy = (double) player.getY() - _point2.y;
  418. +                   if (Math.sqrt(dx * dx + dy * dy) < Config.BOAT_BROADCAST_RADIUS)
  419. +                   {
  420. +                       for (L2GameServerPacket p : _packets)
  421. +                           player.sendPacket(p);
  422. +                   }
  423. +               }
  424.             }
  425. +          
  426. +           return true;
  427.         }
  428.     }
  429.    
  430. Index: java/com/l2jserver/gameserver/instancemanager/TerritoryWarManager.java
  431. ===================================================================
  432. --- java/com/l2jserver/gameserver/instancemanager/TerritoryWarManager.java  (revision 4790)
  433. +++ java/com/l2jserver/gameserver/instancemanager/TerritoryWarManager.java  (working copy)
  434. @@ -1118,7 +1118,7 @@
  435.         {
  436.             if (isTWInProgress())
  437.             {
  438. -               for(L2PcInstance player : L2World.getInstance().getAllPlayers().values())
  439. +               for(L2PcInstance player : L2World.getInstance().getAllPlayersArray())
  440.                     if (player != null && player.getSiegeSide() > 0)
  441.                         giveTWPoint(player, 1000, 6);
  442.             }
  443. Index: java/com/l2jserver/gameserver/instancemanager/ZoneManager.java
  444. ===================================================================
  445. --- java/com/l2jserver/gameserver/instancemanager/ZoneManager.java  (revision 4790)
  446. +++ java/com/l2jserver/gameserver/instancemanager/ZoneManager.java  (working copy)
  447. @@ -15,6 +15,8 @@
  448.  
  449.  package com.l2jserver.gameserver.instancemanager;
  450.  
  451. +import gnu.trove.TObjectProcedure;
  452. +
  453.  import java.io.File;
  454.  import java.lang.reflect.Constructor;
  455.  import java.util.Collection;
  456. @@ -97,11 +99,18 @@
  457.         _log.info("Removed zones in " + count + " regions.");
  458.         // Load the zones
  459.         load();
  460. -      
  461. -       for (L2Object o : L2World.getInstance().getAllVisibleObjects().values())
  462. -       {
  463. +       L2World.getInstance().forEachObject(new ForEachCharacterRevalidateZone());
  464. +
  465. +   }
  466. +  
  467. +   private final class ForEachCharacterRevalidateZone implements TObjectProcedure<L2Object>
  468. +   {  
  469. +       @Override
  470. +       public final boolean execute(final L2Object o)
  471. +       {
  472.             if (o instanceof L2Character)
  473.                 ((L2Character) o).revalidateZone(true);
  474. +           return true;
  475.         }
  476.     }
  477.    
  478. Index: java/com/l2jserver/gameserver/model/L2World.java
  479. ===================================================================
  480. --- java/com/l2jserver/gameserver/model/L2World.java    (revision 4790)
  481. +++ java/com/l2jserver/gameserver/model/L2World.java    (working copy)
  482. @@ -14,14 +14,18 @@
  483.   */
  484.  package com.l2jserver.gameserver.model;
  485.  
  486. +import gnu.trove.TIntObjectHashMap;
  487. +import gnu.trove.TObjectProcedure;
  488. +
  489.  import java.util.ArrayList;
  490.  import java.util.Collection;
  491.  import java.util.List;
  492.  import java.util.Map;
  493. +import java.util.concurrent.locks.Lock;
  494. +import java.util.concurrent.locks.ReentrantReadWriteLock;
  495.  import java.util.logging.Logger;
  496.  
  497.  import javolution.util.FastList;
  498. -import javolution.util.FastMap;
  499.  
  500.  import com.l2jserver.Config;
  501.  import com.l2jserver.gameserver.GmListTable;
  502. @@ -75,13 +79,19 @@
  503.     //private FastMap<String, L2PcInstance> _allGms;
  504.    
  505.     /** HashMap(Integer Player id, L2PcInstance) containing all the players in game */
  506. -   private Map<Integer, L2PcInstance> _allPlayers;
  507. +   private TIntObjectHashMap<L2PcInstance> _allPlayers;
  508. +   private final Lock _apRL;
  509. +   private final Lock _apWL;
  510.    
  511.     /** L2ObjectHashMap(L2Object) containing all visible objects */
  512. -   private Map<Integer, L2Object> _allObjects;
  513. +   private TIntObjectHashMap<L2Object> _allObjects;
  514. +   private final Lock _aoRL;
  515. +   private final Lock _aoWL;
  516.    
  517.     /** List with the pets instances and their owner id */
  518. -   private Map<Integer, L2PetInstance> _petsInstance;
  519. +   private TIntObjectHashMap<L2PetInstance> _petsInstance;
  520. +   private final Lock _piRL;
  521. +   private final Lock _piWL;
  522.    
  523.     private L2WorldRegion[][] _worldRegions;
  524.    
  525. @@ -90,10 +100,20 @@
  526.      */
  527.     private L2World()
  528.     {
  529. -       //_allGms    = new FastMap<String, L2PcInstance>();
  530. -       _allPlayers = new FastMap<Integer, L2PcInstance>().shared();
  531. -       _petsInstance = new FastMap<Integer, L2PetInstance>().shared();
  532. -       _allObjects = new FastMap<Integer, L2Object>().shared();
  533. +       ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  534. +       _apRL = lock.readLock();
  535. +       _apWL = lock.writeLock();
  536. +       _allPlayers = new TIntObjectHashMap<L2PcInstance>();
  537. +      
  538. +       lock = new ReentrantReadWriteLock();
  539. +       _aoRL = lock.readLock();
  540. +       _aoWL = lock.writeLock();
  541. +       _allObjects = new TIntObjectHashMap<L2Object>();
  542. +      
  543. +       lock = new ReentrantReadWriteLock();
  544. +       _piRL = lock.readLock();
  545. +       _piWL = lock.writeLock();
  546. +       _petsInstance = new TIntObjectHashMap<L2PetInstance>();
  547.        
  548.         initRegions();
  549.     }
  550. @@ -115,24 +135,52 @@
  551.      */
  552.     public void storeObject(L2Object object)
  553.     {
  554. -       assert !_allObjects.containsKey(object.getObjectId());
  555. -      
  556. -       if (_allObjects.containsKey(object.getObjectId()))
  557. +       _aoWL.lock();
  558. +       try
  559.         {
  560. -           _log.warning("[L2World] object: " + object + " already exist in OID map!");
  561. -           _log.info(StringUtil.getTraceString(Thread.currentThread().getStackTrace()));
  562. -           return;
  563. +           _aoRL.lock();
  564. +           try
  565. +           {
  566. +               assert !_allObjects.containsKey(object.getObjectId());
  567. +              
  568. +               if (_allObjects.containsKey(object.getObjectId()))
  569. +               {
  570. +                   if (Config.DEBUG)
  571. +                   {
  572. +                       _log.warning("[L2World] object: " + object + " already exist in OID map!");
  573. +                       _log.info(StringUtil.getTraceString(Thread.currentThread().getStackTrace()));
  574. +                       return;
  575. +                   }
  576. +               }
  577. +           }
  578. +           finally
  579. +           {
  580. +               _aoRL.unlock();
  581. +           }
  582. +          
  583. +           _allObjects.put(object.getObjectId(), object);
  584.         }
  585. -      
  586. -       _allObjects.put(object.getObjectId(), object);
  587. +       finally
  588. +       {
  589. +           _aoWL.unlock();
  590. +       }
  591.     }
  592.    
  593.     public long timeStoreObject(L2Object object)
  594.     {
  595. -       long time = System.nanoTime();
  596. -       _allObjects.put(object.getObjectId(), object);
  597. -       time = System.nanoTime() - time;
  598. -       return time;
  599. +       _aoWL.lock();
  600. +      
  601. +       try
  602. +       {
  603. +           long time = System.nanoTime();
  604. +           _allObjects.put(object.getObjectId(), object);
  605. +           time = System.nanoTime() - time;
  606. +           return time;
  607. +       }
  608. +       finally
  609. +       {
  610. +           _aoWL.unlock();
  611. +       }
  612.     }
  613.    
  614.     /**
  615. @@ -148,33 +196,69 @@
  616.      */
  617.     public void removeObject(L2Object object)
  618.     {
  619. -       _allObjects.remove(Integer.valueOf(object.getObjectId())); // suggestion by whatev
  620. -       //IdFactory.getInstance().releaseId(object.getObjectId());
  621. +       _aoWL.lock();
  622. +      
  623. +       try
  624. +       {
  625. +           _allObjects.remove(object.getObjectId()); // suggestion by whatev
  626. +           //IdFactory.getInstance().releaseId(object.getObjectId());
  627. +       }
  628. +       finally
  629. +       {
  630. +           _aoWL.unlock();
  631. +       }
  632.     }
  633.    
  634.     public void removeObjects(List<L2Object> list)
  635.     {
  636. -       for (L2Object o : list)
  637. +       _aoWL.lock();
  638. +      
  639. +       try
  640. +       {
  641. +           for (L2Object o : list)
  642. +           {
  643. +               if (o != null)
  644. +                   _allObjects.remove(o.getObjectId()); // suggestion by whatev
  645. +           }
  646. +           //IdFactory.getInstance().releaseId(object.getObjectId());
  647. +       }
  648. +       finally
  649.         {
  650. -           if (o != null)
  651. -               _allObjects.remove(Integer.valueOf(o.getObjectId())); // suggestion by whatev
  652. +           _aoWL.unlock();
  653.         }
  654. -       //IdFactory.getInstance().releaseId(object.getObjectId());
  655.     }
  656.    
  657.     public void removeObjects(L2Object[] objects)
  658.     {
  659. -       for (L2Object o : objects)
  660. -           _allObjects.remove(Integer.valueOf(o.getObjectId())); // suggestion by whatev
  661. -       //IdFactory.getInstance().releaseId(object.getObjectId());
  662. +       _aoWL.lock();
  663. +      
  664. +       try
  665. +       {
  666. +           for (L2Object o : objects)
  667. +               _allObjects.remove(o.getObjectId()); // suggestion by whatev
  668. +           //IdFactory.getInstance().releaseId(object.getObjectId());
  669. +       }
  670. +       finally
  671. +       {
  672. +           _aoWL.unlock();
  673. +       }
  674.     }
  675.    
  676.     public long timeRemoveObject(L2Object object)
  677.     {
  678. -       long time = System.nanoTime();
  679. -       _allObjects.remove(Integer.valueOf(object.getObjectId()));
  680. -       time = System.nanoTime() - time;
  681. -       return time;
  682. +       _aoWL.lock();
  683. +      
  684. +       try
  685. +       {
  686. +           long time = System.nanoTime();
  687. +           _allObjects.remove(object.getObjectId());
  688. +           time = System.nanoTime() - time;
  689. +           return time;
  690. +       }
  691. +       finally
  692. +       {
  693. +           _aoWL.unlock();
  694. +       }
  695.     }
  696.    
  697.     /**
  698. @@ -187,15 +271,33 @@
  699.      */
  700.     public L2Object findObject(int oID)
  701.     {
  702. -       return _allObjects.get(Integer.valueOf(oID));
  703. +       _aoRL.lock();
  704. +      
  705. +       try
  706. +       {
  707. +           return _allObjects.get(oID);
  708. +       }
  709. +       finally
  710. +       {
  711. +           _aoRL.unlock();
  712. +       }
  713.     }
  714.    
  715.     public long timeFindObject(int objectID)
  716.     {
  717. -       long time = System.nanoTime();
  718. -       _allObjects.get(Integer.valueOf(objectID));
  719. -       time = System.nanoTime() - time;
  720. -       return time;
  721. +       _aoRL.lock();
  722. +      
  723. +       try
  724. +       {
  725. +           long time = System.nanoTime();
  726. +           _allObjects.get(objectID);
  727. +           time = System.nanoTime() - time;
  728. +           return time;
  729. +       }
  730. +       finally
  731. +       {
  732. +           _aoRL.unlock();
  733. +       }
  734.     }
  735.    
  736.     /**
  737. @@ -207,9 +309,46 @@
  738.      * @deprecated
  739.      */
  740.     @Deprecated
  741. -   public final Map<Integer, L2Object> getAllVisibleObjects()
  742. +   public final TIntObjectHashMap<L2Object> getAllVisibleObjects()
  743. +   {
  744. +       _aoRL.lock();
  745. +      
  746. +       try
  747. +       {
  748. +           return _allObjects;
  749. +       }
  750. +       finally
  751. +       {
  752. +           _aoRL.unlock();
  753. +       }
  754. +   }
  755. +  
  756. +   public final L2Object[] getAllVisibleObjectsArray()
  757.     {
  758. -       return _allObjects;
  759. +       _aoRL.lock();
  760. +      
  761. +       try
  762. +       {
  763. +           return _allObjects.getValues(new L2Object[_allObjects.size()]);
  764. +       }
  765. +       finally
  766. +       {
  767. +           _aoRL.unlock();
  768. +       }
  769. +   }
  770. +  
  771. +   public final boolean forEachObject(final TObjectProcedure<L2Object> proc)
  772. +   {
  773. +       _aoRL.lock();
  774. +      
  775. +       try
  776. +       {
  777. +           return _allObjects.forEachValue(proc);
  778. +       }
  779. +       finally
  780. +       {
  781. +           _aoRL.unlock();
  782. +       }
  783.     }
  784.    
  785.     /**
  786. @@ -231,9 +370,46 @@
  787.         return GmListTable.getInstance().getAllGms(true);
  788.     }
  789.    
  790. -   public Map<Integer, L2PcInstance> getAllPlayers()
  791. +   public TIntObjectHashMap<L2PcInstance> getAllPlayers()
  792.     {
  793. -       return _allPlayers;
  794. +       _apRL.lock();
  795. +      
  796. +       try
  797. +       {
  798. +           return _allPlayers;
  799. +       }
  800. +       finally
  801. +       {
  802. +           _apRL.unlock();
  803. +       }
  804. +   }
  805. +  
  806. +   public final L2PcInstance[] getAllPlayersArray()
  807. +   {
  808. +       _apRL.lock();
  809. +      
  810. +       try
  811. +       {
  812. +           return _allPlayers.getValues(new L2PcInstance[_allPlayers.size()]);
  813. +       }
  814. +       finally
  815. +       {
  816. +           _apRL.unlock();
  817. +       }
  818. +   }
  819. +  
  820. +   public final boolean forEachPlayer(final TObjectProcedure<L2PcInstance> proc)
  821. +   {
  822. +       _apRL.lock();
  823. +      
  824. +       try
  825. +       {
  826. +           return _allPlayers.forEachValue(proc);
  827. +       }
  828. +       finally
  829. +       {
  830. +           _apRL.unlock();
  831. +       }
  832.     }
  833.    
  834.     /**
  835. @@ -264,7 +440,16 @@
  836.      */
  837.     public L2PcInstance getPlayer(int playerObjId)
  838.     {
  839. -       return _allPlayers.get(Integer.valueOf(playerObjId));
  840. +       _apRL.lock();
  841. +      
  842. +       try
  843. +       {
  844. +           return _allPlayers.get(playerObjId);
  845. +       }
  846. +       finally
  847. +       {
  848. +           _apRL.unlock();
  849. +       }
  850.     }
  851.    
  852.     /**
  853. @@ -274,7 +459,16 @@
  854.      */
  855.     public L2PetInstance getPet(int ownerId)
  856.     {
  857. -       return _petsInstance.get(Integer.valueOf(ownerId));
  858. +       _piRL.lock();
  859. +      
  860. +       try
  861. +       {
  862. +           return _petsInstance.get(ownerId);
  863. +       }
  864. +       finally
  865. +       {
  866. +           _piRL.unlock();
  867. +       }
  868.     }
  869.    
  870.     /**
  871. @@ -285,7 +479,16 @@
  872.      */
  873.     public L2PetInstance addPet(int ownerId, L2PetInstance pet)
  874.     {
  875. -       return _petsInstance.put(ownerId, pet);
  876. +       _piWL.lock();
  877. +      
  878. +       try
  879. +       {
  880. +           return _petsInstance.put(ownerId, pet);
  881. +       }
  882. +       finally
  883. +       {
  884. +           _piWL.unlock();
  885. +       }
  886.     }
  887.    
  888.     /**
  889. @@ -295,7 +498,16 @@
  890.      */
  891.     public void removePet(int ownerId)
  892.     {
  893. -       _petsInstance.remove(Integer.valueOf(ownerId));
  894. +       _piWL.lock();
  895. +      
  896. +       try
  897. +       {
  898. +           _petsInstance.remove(ownerId);
  899. +       }
  900. +       finally
  901. +       {
  902. +           _piWL.unlock();
  903. +       }
  904.     }
  905.    
  906.     /**
  907. @@ -305,7 +517,16 @@
  908.      */
  909.     public void removePet(L2PetInstance pet)
  910.     {
  911. -       _petsInstance.remove(Integer.valueOf(pet.getOwner().getObjectId()));
  912. +       _piWL.lock();
  913. +      
  914. +       try
  915. +       {
  916. +           _petsInstance.remove(pet.getOwner().getObjectId());
  917. +       }
  918. +       finally
  919. +       {
  920. +           _piWL.unlock();
  921. +       }
  922.     }
  923.    
  924.     /**
  925. @@ -348,7 +569,7 @@
  926.            
  927.             if (!player.isTeleporting())
  928.             {
  929. -               L2PcInstance tmp = _allPlayers.get(Integer.valueOf(player.getObjectId()));
  930. +               L2PcInstance tmp = getPlayer(player.getObjectId());
  931.                 if (tmp != null)
  932.                 {
  933.                     _log.warning("Duplicate character!? Closing both characters (" + player.getName() + ")");
  934. @@ -356,7 +577,7 @@
  935.                     tmp.logout();
  936.                     return;
  937.                 }
  938. -               _allPlayers.put(player.getObjectId(), player);
  939. +               addToAllPlayers(player);
  940.             }
  941.         }
  942.        
  943. @@ -394,7 +615,16 @@
  944.      */
  945.     public void addToAllPlayers(L2PcInstance cha)
  946.     {
  947. -       _allPlayers.put(cha.getObjectId(), cha);
  948. +       _apWL.lock();
  949. +      
  950. +       try
  951. +       {
  952. +           _allPlayers.put(cha.getObjectId(), cha);
  953. +       }
  954. +       finally
  955. +       {
  956. +           _apWL.unlock();
  957. +       }
  958.     }
  959.    
  960.     /**
  961. @@ -406,7 +636,17 @@
  962.      */
  963.     public void removeFromAllPlayers(L2PcInstance cha)
  964.     {
  965. -       _allPlayers.remove(Integer.valueOf(cha.getObjectId()));
  966. +       _apWL.lock();
  967. +      
  968. +       try
  969. +       {
  970. +           _allPlayers.remove(cha.getObjectId());
  971. +       }
  972. +       finally
  973. +       {
  974. +           _apWL.unlock();
  975. +       }
  976. +
  977.     }
  978.    
  979.     /**
  980. Index: java/com/l2jserver/gameserver/model/actor/instance/L2CastleTeleporterInstance.java
  981. ===================================================================
  982. --- java/com/l2jserver/gameserver/model/actor/instance/L2CastleTeleporterInstance.java  (revision 4790)
  983. +++ java/com/l2jserver/gameserver/model/actor/instance/L2CastleTeleporterInstance.java  (working copy)
  984. @@ -14,7 +14,8 @@
  985.   */
  986.  package com.l2jserver.gameserver.model.actor.instance;
  987.  
  988. -import java.util.Collection;
  989. +import gnu.trove.TObjectProcedure;
  990. +
  991.  import java.util.StringTokenizer;
  992.  import java.util.logging.Level;
  993.  import java.util.logging.Logger;
  994. @@ -110,15 +111,7 @@
  995.                 NpcSay cs = new NpcSay(getObjectId(), 1, getNpcId(), 1000443); // The defenders of $s1 castle will be teleported to the inner castle.
  996.                 cs.addStringParameter(getCastle().getName());
  997.                 int region = MapRegionManager.getInstance().getMapRegionLocId(getX(), getY());
  998. -               Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  999. -               //synchronized (L2World.getInstance().getAllPlayers())
  1000. -               {
  1001. -                   for (L2PcInstance player : pls)
  1002. -                   {
  1003. -                       if (region == MapRegionManager.getInstance().getMapRegionLocId(player.getX(), player.getY()))
  1004. -                           player.sendPacket(cs);
  1005. -                   }
  1006. -               }
  1007. +               L2World.getInstance().forEachPlayer(new ForEachPlayerInRegionSendPacket(region, cs));
  1008.                 oustAllPlayers();
  1009.                 setTask(false);
  1010.             }
  1011. @@ -129,6 +122,26 @@
  1012.         }
  1013.     }
  1014.    
  1015. +   private final class ForEachPlayerInRegionSendPacket implements TObjectProcedure<L2PcInstance>
  1016. +   {
  1017. +       int _region;
  1018. +       NpcSay _cs;
  1019. +      
  1020. +       private ForEachPlayerInRegionSendPacket(int region, NpcSay cs)
  1021. +       {
  1022. +           _region = region;
  1023. +           _cs = cs;
  1024. +       }
  1025. +      
  1026. +       @Override
  1027. +       public final boolean execute(final L2PcInstance player)
  1028. +       {
  1029. +           if (_region == MapRegionManager.getInstance().getMapRegionLocId(player.getX(), player.getY()))
  1030. +               player.sendPacket(_cs);
  1031. +           return true;
  1032. +       }
  1033. +   }
  1034. +  
  1035.     public boolean getTask()
  1036.     {
  1037.         return _currentTask;
  1038. Index: java/com/l2jserver/gameserver/model/actor/instance/L2SepulcherNpcInstance.java
  1039. ===================================================================
  1040. --- java/com/l2jserver/gameserver/model/actor/instance/L2SepulcherNpcInstance.java  (revision 4790)
  1041. +++ java/com/l2jserver/gameserver/model/actor/instance/L2SepulcherNpcInstance.java  (working copy)
  1042. @@ -14,7 +14,8 @@
  1043.   */
  1044.  package com.l2jserver.gameserver.model.actor.instance;
  1045.  
  1046. -import java.util.Collection;
  1047. +import gnu.trove.TObjectProcedure;
  1048. +
  1049.  import java.util.concurrent.Future;
  1050.  
  1051.  import com.l2jserver.Config;
  1052. @@ -433,16 +434,29 @@
  1053.     {
  1054.         if (msg == null || msg.isEmpty())
  1055.             return;// wrong usage
  1056. -       Collection<L2PcInstance> knownPlayers = L2World.getInstance().getAllPlayers().values();
  1057. -       if (knownPlayers == null || knownPlayers.isEmpty())
  1058. -           return;
  1059. -       CreatureSay sm = new CreatureSay(0, Say2.SHOUT, this.getName(), msg);
  1060. -       for (L2PcInstance player : knownPlayers)
  1061. +      
  1062. +       L2World.getInstance().forEachPlayer(new SayInShout(this, new CreatureSay(0, Say2.SHOUT, this.getName(), msg)));
  1063. +   }
  1064. +  
  1065. +   private final class SayInShout implements TObjectProcedure<L2PcInstance>
  1066. +   {
  1067. +       L2SepulcherNpcInstance _npc;
  1068. +       CreatureSay _sm;
  1069. +      
  1070. +       private SayInShout(L2SepulcherNpcInstance npc, CreatureSay sm)
  1071.         {
  1072. -           if (player == null)
  1073. -               continue;
  1074. -           if (Util.checkIfInRange(15000, player, this, true))
  1075. -               player.sendPacket(sm);
  1076. +           _npc = npc;
  1077. +           _sm = sm;
  1078. +       }
  1079. +       @Override
  1080. +       public final boolean execute(final L2PcInstance player)
  1081. +       {
  1082. +           if (player != null)
  1083. +           {
  1084. +               if (Util.checkIfInRange(15000, player, _npc, true))
  1085. +                   player.sendPacket(_sm);
  1086. +           }
  1087. +           return true;
  1088.         }
  1089.     }
  1090.    
  1091. Index: java/com/l2jserver/gameserver/model/entity/Fort.java
  1092. ===================================================================
  1093. --- java/com/l2jserver/gameserver/model/entity/Fort.java    (revision 4790)
  1094. +++ java/com/l2jserver/gameserver/model/entity/Fort.java    (working copy)
  1095. @@ -15,12 +15,12 @@
  1096.  package com.l2jserver.gameserver.model.entity;
  1097.  
  1098.  import gnu.trove.TIntIntHashMap;
  1099. +import gnu.trove.TObjectProcedure;
  1100.  
  1101.  import java.sql.Connection;
  1102.  import java.sql.PreparedStatement;
  1103.  import java.sql.ResultSet;
  1104.  import java.util.Calendar;
  1105. -import java.util.Collection;
  1106.  import java.util.List;
  1107.  import java.util.concurrent.ScheduledFuture;
  1108.  import java.util.concurrent.TimeUnit;
  1109. @@ -965,11 +965,7 @@
  1110.                 sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CLAN_IS_VICTORIOUS_IN_THE_FORTRESS_BATTLE_OF_S2);
  1111.                 sm.addString(clan.getName());
  1112.                 sm.addFortId(getFortId());
  1113. -               Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  1114. -               for (L2PcInstance player : pls)
  1115. -               {
  1116. -                   player.sendPacket(sm);
  1117. -               }
  1118. +               L2World.getInstance().forEachPlayer(new ForEachPlayerSendMessage(sm));
  1119.                 clan.broadcastToOnlineMembers(new PledgeShowInfoUpdate(clan));
  1120.                 clan.broadcastToOnlineMembers(new PlaySound(1, "Siege_Victory", 0, 0, 0, 0, 0));
  1121.                 if (_FortUpdater[0] != null)
  1122. @@ -1480,4 +1476,19 @@
  1123.                 player.removeSkill(sk, false, true);
  1124.         }
  1125.     }
  1126. +  
  1127. +   private final class ForEachPlayerSendMessage implements TObjectProcedure<L2PcInstance>
  1128. +   {
  1129. +       SystemMessage _sm;
  1130. +       private ForEachPlayerSendMessage(SystemMessage sm)
  1131. +       {
  1132. +           _sm = sm;
  1133. +       }
  1134. +       @Override
  1135. +       public final boolean execute(final L2PcInstance character)
  1136. +       {
  1137. +           character.sendPacket(_sm);
  1138. +           return true;
  1139. +       }
  1140. +   }
  1141.  }
  1142. Index: java/com/l2jserver/gameserver/model/entity/L2Event.java
  1143. ===================================================================
  1144. --- java/com/l2jserver/gameserver/model/entity/L2Event.java (revision 4790)
  1145. +++ java/com/l2jserver/gameserver/model/entity/L2Event.java (working copy)
  1146. @@ -372,7 +372,7 @@
  1147.             _eventInfo = inbr.readLine();
  1148.            
  1149.             List<L2PcInstance> temp = new FastList<L2PcInstance>();
  1150. -           for (L2PcInstance player : L2World.getInstance().getAllPlayers().values())
  1151. +           for (L2PcInstance player : L2World.getInstance().getAllPlayersArray())
  1152.             {
  1153.                 if (!player.isOnline()) // Offline shops?
  1154.                     continue;
  1155. Index: java/com/l2jserver/gameserver/network/clientpackets/RequestStartPledgeWar.java
  1156. ===================================================================
  1157. --- java/com/l2jserver/gameserver/network/clientpackets/RequestStartPledgeWar.java  (revision 4790)
  1158. +++ java/com/l2jserver/gameserver/network/clientpackets/RequestStartPledgeWar.java  (working copy)
  1159. @@ -14,7 +14,7 @@
  1160.   */
  1161.  package com.l2jserver.gameserver.network.clientpackets;
  1162.  
  1163. -import java.util.Collection;
  1164. +import gnu.trove.TObjectProcedure;
  1165.  
  1166.  import com.l2jserver.Config;
  1167.  import com.l2jserver.gameserver.datatables.ClanTable;
  1168. @@ -135,12 +135,22 @@
  1169.         //        leader.sendPacket(new StartPledgeWar(_clan.getName(),player.getName()));
  1170.        
  1171.         ClanTable.getInstance().storeclanswars(player.getClanId(), clan.getClanId());
  1172. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  1173. -       //synchronized (L2World.getInstance().getAllPlayers())
  1174. +       L2World.getInstance().forEachPlayer(new ForEachPlayerBroadcastUserInfo(clan));
  1175. +   }
  1176. +  
  1177. +   private final class ForEachPlayerBroadcastUserInfo implements TObjectProcedure<L2PcInstance>
  1178. +   {
  1179. +       L2Clan _cln;
  1180. +       private ForEachPlayerBroadcastUserInfo(L2Clan clan)
  1181.         {
  1182. -           for (L2PcInstance cha : pls)
  1183. -               if (cha.getClan() == player.getClan() || cha.getClan() == clan)
  1184. -                   cha.broadcastUserInfo();
  1185. +           _cln = clan;
  1186. +       }
  1187. +       @Override
  1188. +       public final boolean execute(final L2PcInstance cha)
  1189. +       {
  1190. +           if (cha.getClan() == player.getClan() || cha.getClan() == _cln)
  1191. +               cha.broadcastUserInfo();
  1192. +           return true;
  1193.         }
  1194.     }
  1195.    
  1196. Index: java/com/l2jserver/gameserver/network/clientpackets/RequestStopPledgeWar.java
  1197. ===================================================================
  1198. --- java/com/l2jserver/gameserver/network/clientpackets/RequestStopPledgeWar.java   (revision 4790)
  1199. +++ java/com/l2jserver/gameserver/network/clientpackets/RequestStopPledgeWar.java   (working copy)
  1200. @@ -14,7 +14,7 @@
  1201.   */
  1202.  package com.l2jserver.gameserver.network.clientpackets;
  1203.  
  1204. -import java.util.Collection;
  1205. +import gnu.trove.TObjectProcedure;
  1206.  
  1207.  import com.l2jserver.gameserver.datatables.ClanTable;
  1208.  import com.l2jserver.gameserver.model.L2Clan;
  1209. @@ -102,12 +102,24 @@
  1210.         }
  1211.        
  1212.         ClanTable.getInstance().deleteclanswars(playerClan.getClanId(), clan.getClanId());
  1213. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  1214. -       //synchronized (L2World.getInstance().getAllPlayers())
  1215. +       L2World.getInstance().forEachPlayer(new ForEachPlayerBroadcastUserInfo(clan, player));
  1216. +   }
  1217. +  
  1218. +   private final class ForEachPlayerBroadcastUserInfo implements TObjectProcedure<L2PcInstance>
  1219. +   {
  1220. +       L2PcInstance _player;
  1221. +       L2Clan _cln;
  1222. +       private ForEachPlayerBroadcastUserInfo(L2Clan clan, L2PcInstance player)
  1223.         {
  1224. -           for (L2PcInstance cha : pls)
  1225. -               if (cha.getClan() == player.getClan() || cha.getClan() == clan)
  1226. -                   cha.broadcastUserInfo();
  1227. +           _cln = clan;
  1228. +           _player = player;
  1229. +       }
  1230. +       @Override
  1231. +       public final boolean execute(final L2PcInstance cha)
  1232. +       {
  1233. +           if (cha.getClan() == _player.getClan() || cha.getClan() == _cln)
  1234. +               cha.broadcastUserInfo();
  1235. +           return true;
  1236.         }
  1237.     }
  1238.    
  1239. Index: java/com/l2jserver/gameserver/util/Broadcast.java
  1240. ===================================================================
  1241. --- java/com/l2jserver/gameserver/util/Broadcast.java   (revision 4790)
  1242. +++ java/com/l2jserver/gameserver/util/Broadcast.java   (working copy)
  1243. @@ -24,6 +24,8 @@
  1244.   */
  1245.  package com.l2jserver.gameserver.util;
  1246.  
  1247. +import gnu.trove.TObjectProcedure;
  1248. +
  1249.  import java.util.Collection;
  1250.  import java.util.logging.Level;
  1251.  import java.util.logging.Logger;
  1252. @@ -218,13 +220,7 @@
  1253.         if (Config.DEBUG)
  1254.             _log.fine("Players to notify: " + L2World.getInstance().getAllPlayersCount() + " (with packet " + mov.getType() + ")");
  1255.        
  1256. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  1257. -       // synchronized (L2World.getInstance().getAllPlayers())
  1258. -       {
  1259. -           for (L2PcInstance onlinePlayer : pls)
  1260. -               if (onlinePlayer != null && onlinePlayer.isOnline())
  1261. -                   onlinePlayer.sendPacket(mov);
  1262. -       }
  1263. +       L2World.getInstance().forEachPlayer(new ForEachPlayerBroadcast(mov));
  1264.     }
  1265.    
  1266.     public static void announceToOnlinePlayers(String text)
  1267. @@ -235,14 +231,42 @@
  1268.    
  1269.     public static void toPlayersInInstance(L2GameServerPacket mov, int instanceId)
  1270.     {
  1271. -       Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  1272. -       //synchronized (character.getKnownList().getKnownPlayers())
  1273. +       L2World.getInstance().forEachPlayer(new ForEachPlayerInInstanceBroadcast(mov, instanceId));
  1274. +   }
  1275. +  
  1276. +   private static final class ForEachPlayerBroadcast implements TObjectProcedure<L2PcInstance>
  1277. +   {
  1278. +       L2GameServerPacket _packet;
  1279. +       private ForEachPlayerBroadcast(L2GameServerPacket packet)
  1280.         {
  1281. -           for (L2PcInstance onlinePlayer : pls)
  1282. -           {
  1283. -               if (onlinePlayer != null && onlinePlayer.isOnline() && onlinePlayer.getInstanceId() == instanceId)
  1284. -                   onlinePlayer.sendPacket(mov);
  1285. -           }
  1286. +           _packet = packet;
  1287. +       }
  1288. +      
  1289. +       @Override
  1290. +       public final boolean execute(final L2PcInstance onlinePlayer)
  1291. +       {
  1292. +           if (onlinePlayer != null && onlinePlayer.isOnline())
  1293. +               onlinePlayer.sendPacket(_packet);
  1294. +           return true;
  1295. +       }
  1296. +   }
  1297. +  
  1298. +   private static final class ForEachPlayerInInstanceBroadcast implements TObjectProcedure<L2PcInstance>
  1299. +   {
  1300. +       L2GameServerPacket _packet;
  1301. +       int _instanceId;
  1302. +       private ForEachPlayerInInstanceBroadcast(L2GameServerPacket packet, int instanceId)
  1303. +       {
  1304. +           _packet = packet;
  1305. +           _instanceId = instanceId;
  1306. +       }
  1307. +      
  1308. +       @Override
  1309. +       public final boolean execute(final L2PcInstance onlinePlayer)
  1310. +       {
  1311. +           if (onlinePlayer != null && onlinePlayer.isOnline() && onlinePlayer.getInstanceId() == _instanceId)
  1312. +               onlinePlayer.sendPacket(_packet);
  1313. +           return true;
  1314.         }
  1315.     }
  1316.  }
  1317. Index: java/com/l2jserver/status/GameStatusThread.java
  1318. ===================================================================
  1319. --- java/com/l2jserver/status/GameStatusThread.java (revision 4790)
  1320. +++ java/com/l2jserver/status/GameStatusThread.java (working copy)
  1321. @@ -34,7 +34,6 @@
  1322.  import java.text.DecimalFormat;
  1323.  import java.text.SimpleDateFormat;
  1324.  import java.util.Calendar;
  1325. -import java.util.Collection;
  1326.  import java.util.Map;
  1327.  import java.util.Map.Entry;
  1328.  import java.util.NoSuchElementException;
  1329. @@ -856,10 +855,9 @@
  1330.                         // name;type;x;y;itemId:enchant:price...
  1331.                         if (type.equals("privatestore"))
  1332.                         {
  1333. -                           Collection<L2PcInstance> pls = L2World.getInstance().getAllPlayers().values();
  1334.                             //synchronized (L2World.getInstance().getAllPlayers())
  1335.                             {
  1336. -                               for (L2PcInstance player : pls)
  1337. +                               for (L2PcInstance player : L2World.getInstance().getAllPlayersArray())
  1338.                                 {
  1339.                                     if (player.getPrivateStoreType() == 0)
  1340.                                         continue;
  1341. @@ -1087,10 +1085,9 @@
  1342.         int summonCount = 0;
  1343.         int AICount = 0;
  1344.        
  1345. -       Collection<L2Object> objs = L2World.getInstance().getAllVisibleObjects().values();
  1346.         //synchronized (L2World.getInstance().getAllVisibleObjects())
  1347.         {
  1348. -           for (L2Object obj : objs)
  1349. +           for (L2Object obj : L2World.getInstance().getAllVisibleObjectsArray())
  1350.             {
  1351.                 if (obj == null)
  1352.                     continue;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!