我正在使用一个线程(我们称它为 "MapChecker")，它的整个生命周期都在一个ConcurrentHashMap上循环。
该地图由其他线程填充，MapChecker通过使用迭代器清除它。
地图具有以下结构。
private volatile Map<MyObject, SynchronizedList<MyOtherObject>> map = new ConcurrentHashMap<>();
//SynchronizedList = Collections.syncrhonizedList.
MapChecker必须在其循环中更新每个键的值。更新的方式是从列表中删除元素或删除整个地图条目。
同步发生在两个步骤上。
锁定在mapitself上（synchronized(map) ）。
我不在乎在迭代器视图中总是有最后更新的值，但我需要确保所有缺失的值将在下一次迭代中被检索到，这很重要，因为我不想跳过任何元素。此外，正确更新SynchronizedList也很重要。
我的问题是：通过这种架构，我可以确保所有插入的条目都被更新吗？如果MapChecker删除了一个条目，而另一个线程正在更新同一个条目，会发生什么？ConcurrentHashMap应该会阻止这些操作，所以我希望不会有问题。
这是MapChecker的循环。
while (!isInterrupted()) {
executeClearingPhases();
Iterator<Map.Entry<PoolManager, List<PooledObject>>> it = null;
synchronized (idleInstancesMap) {
it = idleInstancesMap.entrySet().iterator();
}
while (it.hasNext()) {
Map.Entry<PoolManager, List<PooledObject>> entry = it.next();
PoolManager poolManager = entry.getKey();
boolean stop = false;
while (!stop) {
//this list is empty very often but it shouldn't, that's the problem I am facing. I need to assure updates visibility.
List<PooledObject> idlePooledObjects = entry.getValue();
if (idlePooledObjects.isEmpty()) {
stop = true;
} else {
PooledObject pooledObject = null;
try {
pooledObject = idlePooledObjects.get(0);
info(loggingId, " - REMOOOVINNGG: \"", pooledObject.getClientId(), "\".");
PoolingStatus destroyStatus = poolManager.destroyIfExpired(pooledObject);
switch (destroyStatus) {
case DESTROY:
info(loggingId, " - Removed pooled object \"", pooledObject.getClientId(), "\" from pool: \"", poolManager.getClientId(), "\".");
idlePooledObjects.remove(0);
break;
case IDLE:
stop = true;
break;
default:
idlePooledObjects.remove(0);
break;
}
} catch (@SuppressWarnings("unused") PoolDestroyedException e) {
warn(loggingId, " - WARNING: Pooled object \"", pooledObject.getClientId(), "\" skipped, pool: \"", poolManager.getClientId(), "\" has been destroyed.");
synchronized(idleInstancesMap) {
it.remove();
}
stop = true;
} catch (PoolManagementException e) {
error(e, loggingId, " - ERROR: Errors occurred during the operation.");
idlePooledObjects.remove(0);
}
}
}
}
Thread.yield();
}
这是被其他线程调用（多次）的方法。
public void addPooledObject(PoolManager poolManager, PooledObject pooledObject) {
synchronized (idleInstancesMap) {
List<PooledObject> idleInstances = idleInstancesMap.get(poolManager);
if (idleInstances == null) {
idleInstances = Collections.synchronizedList(new LinkedList<PooledObject>());
idleInstancesMap.put(poolManager, idleInstances);
}
idleInstances.add(pooledObject);
}
}
谢谢你
但我需要确保所有缺失的值会在下一次迭代中被检索到，这一点很重要，因为我不想跳过任何元素。
首先，我认为根据你的解决方案，我认为只要你继续执行 MapChecker loop. 我建议你在下面的 MapChecker 你提出的代码。
但是根据你的描述，我建议你应该使用Queue而不是Map，很明显，你的问题需要一个pushpop操作，也许是 BlockingQueue 在这里比较合适。
感谢PatrickChen的建议，我把PooledObject实例列表移到了每个PoolManager内部（它已经拥有这个列表，因为它以完全同步的方式拥有池及其内部状态）。
这就是结果。
//MapChecker lifecycle
public void run() {
try {
while (!isInterrupted()) {
executeClearingPhases();
ListIterator<PoolManager> it = null;
//This really helps. poolManagers is the list of PoolManager instances.
//It's unlikely that this list will have many elements (maybe not more than 20)
synchronized (poolManagers) {
Iterator<PoolManager> originalIt = poolManagers.iterator();
while (originalIt.hasNext()) {
if (originalIt.next().isDestroyed()) {
originalIt.remove();
}
}
//This iterator will contain the current view of the list.
//It will update on the next iteration.
it = new LinkedList<PoolManager>(poolManagers).listIterator();
}
while (it.hasNext()) {
PoolManager poolManager = it.next();
try {
//This method will lock on its internal synchronized pool in order to
//scan for expired objects.
poolManager.destroyExpired();
} catch (@SuppressWarnings("unused") PoolDestroyedException e) {
warn(loggingId, " - WARNING: Pool: \"", poolManager.getClientId(), "\" has been destroyed.");
it.remove();
}
}
Thread.yield();
}
throw new InterruptedException();
} catch (@SuppressWarnings("unused") InterruptedException e) {
started = false;
Thread.currentThread().interrupt();
debug(loggingId, " - Pool checker interrupted.");
}
}
//Method invoked by multiple threads
public void addPooledObject(PoolManager poolManager) {
synchronized (poolManagers) {
poolManagers.add(poolManager);
}
}