3

我需要一个支持并发的映射的实现，并且只存储最少/最多的附加值（取决于比较器）。下面的代码会起作用吗？

 class LeastValConcurrentMap<K, V> {

  //put the least value
  private final Comparator<V> comparator;
  private final ConcurrentHashMap<K, V> map = new ConcurrentHashMap<K, V>();

  LeastValConcurrentMap(Comparator comparator) {
     this.comparator = comparator;
  }

  public void put(K k, V v)  {
     V vOld = map.put(k, v);
     if (vOld == null || comparator.compare(v, vOld) <= 0) //i.e. v <= vOld so better
        return;
     //recursively call self
     put(k, vOld);
  }

  @Override
  public String toString() {
     return map.toString();
  }
}

你能给我一个例子，说明它在哪里/为什么不起作用？番石榴或标准 java 库中有什么我可以使用的吗？

4

2 回答 2

2

我认为它更复杂，你需要使用 atomicConcurrentHashMap.replace(K key, V oldValue, V newValue) 

public void put(K k, V v) {
    V oldValue = map.putIfAbsent(k, v);
    if (oldValue == null) {
        // this is the first mapping to this key 
        return;
    }
    for (;;) {
        if (comparator.compare(v, oldValue) <= 0) {
            break;
        }
        // this replace returns true only if oldValue was replaced with new value atomically   
        if (map.replace(k, oldValue, v)) {
            break;
        }
        // otherwise another attempt
        oldValue = map.get(k);
    }
于 2013-04-26T14:41:44.290 回答
0

您可能需要同步 LeastValConcurrentMap 类的 put 方法。似乎您只是将值放入地图中。这些值将在哪里/如何使用。为了确保并发访问，您需要考虑读/写操作。你的 put 方法的最后一行也应该像 map.put(k, vOld)

于 2013-04-26T14:41:37.453 回答