/* * This program is free software: you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation, either version 3 of the License, or (at your option) any later * version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License along with * this program. If not, see <http://www.gnu.org/licenses/>. */package com.l2jserver.gameserver.util;import gnu.trove.function.TObjectFunction;import gnu.trove.map.hash.TIntObjectHashMap;import gnu.trove.procedure.TIntObjectProcedure;import gnu.trove.procedure.TIntProcedure;import gnu.trove.procedure.TObjectProcedure;import java.util.Collection;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantReadWriteLock;/** * Custom extension of TIntObjectHashMap that is synchronized via ReentrantReadWriteLock.<br> * The purpose of this map is to replace the use of FastMap<K,V>.shared() which requires a lot of resources. * @author Nik * @param <V> value object. */public class L2TIntObjectHashMap<V extends Object> extends TIntObjectHashMap<V>{ private static final long serialVersionUID = 1L; private final TIntObjectHashMap<V> _map; private final ReentrantReadWriteLock _lock = new ReentrantReadWriteLock(); private final Lock _readLock = _lock.readLock(); private final Lock _writeLock = _lock.writeLock(); public L2TIntObjectHashMap() { _map = new TIntObjectHashMap<V>(); } public L2TIntObjectHashMap(TIntObjectHashMap<V> map) { _map = map; } @Override public V put(int key, V value) { _writeLock.lock(); try { return _map.put(key, value); } finally { _writeLock.unlock(); } } /** * Unsynchronized operation, its free from any locks.<br> * Its useful while the readLock is taken by a thread<br> * (forEach operation for example)<br> * and you need to put something in the map without causing a deadlock<br> * by taking the writeLock before the readLock is unlocked. * @param key * @param value * @return * @deprecated */ @Deprecated public V unsynchronizedPut(int key, V value) { return _map.put(key, value); } @Override public V get(int key) { _readLock.lock(); try { return _map.get(key); } finally { _readLock.unlock(); } } @Override public void clear() { _writeLock.lock(); try { _map.clear(); } finally { _writeLock.unlock(); } } @Override public V remove(int key) { _writeLock.lock(); try { return _map.remove(key); } finally { _writeLock.unlock(); } } /** * Unsynchronized operation, its free from any locks.<br> * Its useful while the readLock is taken by a thread * (forEach operation for example)<br> * and you need to remove something in the map without causing a deadlock<br> * by taking the writeLock before the readLock is unlocked. * @param key * @return */ public V unsynchronizedRemove(int key) { return _map.remove(key); } @Override public boolean equals(Object other) { _readLock.lock(); try { return _map.equals(other); } finally { _readLock.unlock(); } } @Override public V[] values() { _readLock.lock(); try { return _map.values(); } finally { _readLock.unlock(); } } @Override public V[] values(V[] arg0) { _readLock.lock(); try { return _map.values(arg0); } finally { _readLock.unlock(); } } @Override public Collection<V> valueCollection() { _readLock.lock(); try { return _map.valueCollection(); } finally { _readLock.unlock(); } } @Override public int[] keys() { _readLock.lock(); try { return _map.keys(); } finally { _readLock.unlock(); } } @Override public int[] keys(int[] arg0) { _readLock.lock(); try { return _map.keys(arg0); } finally { _readLock.unlock(); } } @Override public boolean contains(int val) { _readLock.lock(); try { return _map.contains(val); } finally { _readLock.unlock(); } } @Override public boolean containsValue(Object arg0) { _readLock.lock(); try { return _map.containsValue(arg0); } finally { _readLock.unlock(); } } @Override public boolean containsKey(int key) { _readLock.lock(); try { return _map.containsKey(key); } finally { _readLock.unlock(); } } @Override public boolean forEachKey(TIntProcedure procedure) { _readLock.lock(); try { return _map.forEachKey(procedure); } finally { _readLock.unlock(); } } /** * A safe from deadlock loop.<br> * put and remove synchronizers are disabled while this loop is running.<br> * Keep in mind that this uses writeLock instead of readLock,<br> * and its intended only if you are trying to put/remove something while looping<br> * the values of this map. * @param procedure * @return */ public boolean safeForEachKey(TIntProcedure procedure) { _writeLock.lock(); try { return _map.forEachKey(procedure); } finally { _writeLock.unlock(); } } @Override public boolean forEachValue(TObjectProcedure<? super V> arg0) { _readLock.lock(); try { return _map.forEachValue(arg0); } finally { _readLock.unlock(); } } /** * A safe from deadlock loop.<br> * put and remove synchronizers are disabled while this loop is running.<br> * Keep in mind that this uses writeLock instead of readLock,<br> * and its intended only if you are trying to put/remove something while looping<br> * the values of this map. * @param arg0 * @return */ public boolean safeForEachValue(TObjectProcedure<V> arg0) { _writeLock.lock(); try { return _map.forEachValue(arg0); } finally { _writeLock.unlock(); } } @Override public boolean forEachEntry(TIntObjectProcedure<? super V> arg0) { _readLock.lock(); try { return _map.forEachEntry(arg0); } finally { _readLock.unlock(); } } /** * A safe from deadlock loop.<br> * put and remove synchronizers are disabled while this loop is running.<br> * Keep in mind that this uses writeLock instead of readLock, * <br>and its intended only if you are trying to put/remove something while looping<br> * the values of this map. * @param arg0 * @return */ public boolean safeForEachEntry(TIntObjectProcedure<V> arg0) { _writeLock.lock(); try { return _map.forEachEntry(arg0); } finally { _writeLock.unlock(); } } @Override public boolean retainEntries(TIntObjectProcedure<? super V> arg0) { _writeLock.lock(); try { return _map.retainEntries(arg0); } finally { _writeLock.unlock(); } } @Override public void transformValues(TObjectFunction<V, V> arg0) { _writeLock.lock(); try { _map.transformValues(arg0); } finally { _writeLock.unlock(); } }}