迭代WeakHashMap [英] Iterating a WeakHashMap
问题描述
我正在同时使用WeakHashMap。我想基于Integer参数实现细粒度锁定;如果线程A需要修改由Integer a
标识的资源,并且线程B对由Integer b
标识的资源执行相同操作,然后他们不需要同步。但是,如果有两个线程使用相同的资源,假设线程C也使用由Integer a
标识的资源,那么当然线程A和C需要同步相同的锁定。
I'm using a WeakHashMap concurrently. I want to achieve fine-grained locking based on an Integer parameter; if thread A needs to modify a resource identified by Integer a
and thread B does the same for resource identified by Integer b
, then they need not to be synchronized. However, if there are two threads using the same resource, say thread C is also using a resource identified by Integer a
, then of course thread A and C need to synchronize on the same Lock.
当没有更多的线程需要ID为X的资源时,可以删除Map中的Lock = X的锁定。但是,另一个线程可以在此时进入并尝试在Map中使用ID = X的锁,因此在添加/删除锁时我们需要全局同步。 (这将是每个线程必须同步的唯一地方,无论Integer参数如何)但是,一个线程无法知道何时删除锁,因为它不知道它是使用锁的最后一个线程。
When there are no more threads that need the resource with ID X then the Lock in the Map for key=X can be removed. However, another thread can come in at that moment and try to use the lock in the Map for ID=X, so we need global synchronization when adding/removing the lock. (This would be the only place where every thread must synchronize, regardless of the Integer parameter) But, a thread cannot know when to remove the lock, because it doesn't know it is the last thread using the lock.
这就是我使用WeakHashMap的原因:当不再使用ID时,可以在GC需要时删除键值对。
That's why I'm using a WeakHashMap: when the ID is no longer used, the key-value pair can be removed when the GC wants it.
为了确保我对现有条目的键有强引用,并且确切地说是构成映射键的对象引用,我需要迭代映射的keySet:
To make sure I have a strong reference to the key of an already existing entry, and exactly that object reference that forms the key of the mapping, I need to iterate the keySet of the map:
synchronized (mrLocks){
// ... do other stuff
for (Integer entryKey : mrLocks.keySet()) {
if (entryKey.equals(id)) {
key = entryKey;
break;
}
}
// if key==null, no thread has a strong reference to the Integer
// key, so no thread is doing work on resource with id, so we can
// add a mapping (new Integer(id) => new ReentrantLock()) here as
// we are in a synchronized block. We must keep a strong reference
// to the newly created Integer, because otherwise the id-lock mapping
// may already have been removed by the time we start using it, and
// then other threads will not use the same Lock object for this
// resource
}
现在,地图的内容可以在迭代时改变吗?我想不是,因为通过调用 mrLocks.keySet()
,我创建了对迭代范围的所有键的强引用。这是正确的吗?
Now, can the content of the Map change while iterating it? I think not, because by calling mrLocks.keySet()
, I created a strong reference to all keys for the scope of iteration. Is that correct?
推荐答案
由于API没有对keySet()做出任何断言,我建议使用如下的缓存:
As the API makes no assertions about the keySet(), I would recommend a cache usage like this:
private static Map<Integer, Reference<Integer>> lockCache = Collections.synchronizedMap(new WeakHashMap<>());
public static Object getLock(Integer i)
{
Integer monitor = null;
synchronized(lockCache) {
Reference<Integer> old = lockCache.get(i);
if (old != null)
monitor = old.get();
// if no monitor exists yet
if (monitor == null) {
/* clone i for avoiding strong references
to the map's key besides the Object returend
by this method.
*/
monitor = new Integer(i);
lockCache.remove(monitor); //just to be sure
lockCache.put(monitor, new WeakReference<>(monitor));
}
}
return monitor;
}
这样你就可以看到显示器(键本身)的引用了锁定它并允许GC在不再使用它时完成它。
This way you are holding a reference to the monitor (the key itself) while locking on it and allow the GC to finalize it when not using it anymore.
编辑:
在评论中讨论有效载荷之后我想到了一个带有两个缓存的解决方案:
After the discussion about payload in the comments I thought about a solution with two caches:
private static Map<Integer, Reference<ReentrantLock>> lockCache = new WeakHashMap<>();
private static Map<ReentrantLock, Integer> keyCache = new WeakHashMap<>();
public static ReentrantLock getLock(Integer i)
{
ReentrantLock lock = null;
synchronized(lockCache) {
Reference<ReentrantLock> old = lockCache.get(i);
if (old != null)
lock = old.get();
// if no lock exists or got cleared from keyCache already but not from lockCache yet
if (lock == null || !keyCache.containsKey(lock)) {
/* clone i for avoiding strong references
to the map's key besides the Object returend
by this method.
*/
Integer cacheKey = new Integer(i);
lock = new ReentrantLock();
lockCache.remove(cacheKey); // just to be sure
lockCache.put(cacheKey, new WeakReference<>(lock));
keyCache.put(lock, cacheKey);
}
}
return lock;
}
只要存在对有效载荷(锁)的强引用,对 keyCache
中映射整数的强引用可避免从 lockCache
缓存中删除有效负载。
As long as a strong reference to the payload (the lock) exists, the strong reference to the mapped integer in keyCache
avoids the removal of the payload from the lockCache
cache.
这篇关于迭代WeakHashMap的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!