ConcurrentHashMap条件替换(ConcurrentHashMap Conditional Replace)

 我希望能够有条件地替换ConcurrentHashMap中的值。 那就是： 
 
public class PriceTick {
   final String instrumentId;
   ...
   final long timestamp;
   ...
 
 还有一个类（我们称之为TickHolder），它拥有一个ConcurrentHashMap（让我们只称它为map ）。 
 
 我希望能够实现条件put方法，这样如果没有键的条目，则插入新的条目，但是如果存在现有条目，则只有在新PriceTick中的时间戳值时才插入新条目。大于现有的 。 
 
 对于老式的HashMap解决方案，TickHolder会有一个put方法： 
 
public void add(PriceTick tick) {
   synchronized(map) {
      if ((map.get(tick.instrumentId) == null)
         || (tick.getTimestamp() > map.get(tick.instrumentId).getTimestamp()) )
         map.put(tick.instrumentId, tick);
      }
}
 
 使用ConcurrentHashMap，人们可能希望删除同步并使用像replace这样的原子方法，但这是无条件的。 很明显，必须编写“条件替换”方法。 
 
 但是，由于测试和替换操作是非原子的，为了保证线程安全，它必须同步 - 但是我对ConcurrentHashMap源的初始读取使我认为外部同步和它们的内部锁定不会工作得非常好，所以至少每个执行结构更改的Map方法和包含类的执行必须由包含类同步......即使这样，我也会感到非常不安。 
 
 我想过继承ConcurrentHashMap，但这似乎是不可能的。 它使用具有默认访问权限的内部最终类HashEntry，因此尽管ConcurrentHashMap不是final，但它不可扩展。 
 
 这似乎意味着我必须回到实现TickHolder包含一个老派的HashMap才能编写我的条件替换方法。 
 
 所以，问题是：我对上述情况是否正确？ 我（希望）是否遗漏了一些明显或微妙的东西，这会导致不同的结论？ 我真的希望能够在这里使用那个可爱的条纹锁定机制。 

I'd like to be able to conditionally replace a value in a ConcurrentHashMap. That is, given:
 
public class PriceTick {
   final String instrumentId;
   ...
   final long timestamp;
   ...
 
And a class (let's call it TickHolder) which owns a ConcurrentHashMap (let's just call it map).
 
I wish to be able to implement a conditional put method, so that if there's no entry for the key, the new one is inserted, but if there is an existing entry, the new one is inserted only if the timestamp value in the new PriceTick is greater than the existing one.
 
For an old-school HashMap solution, TickHolder would have a put method:
 
public void add(PriceTick tick) {
   synchronized(map) {
      if ((map.get(tick.instrumentId) == null)
         || (tick.getTimestamp() > map.get(tick.instrumentId).getTimestamp()) )
         map.put(tick.instrumentId, tick);
      }
}
 
With a ConcurrentHashMap, one would want to drop the synchronization and use some atomic method like replace, but that's unconditional. So clearly the "conditional replace" method must be written. 
 
However, since the test-and-replace operation is non-atomic, in order to be thread safe, it would have to be synchronized - but my initial reading of the ConcurrentHashMap source leads me to think that external synchronization and their internal locks will not work very well, so at a very minimum, every Map method which performs structural changes and the containing class performs would have to be synchronized by the containing class... and even then, I'm going to be fairly uneasy.
 
I thought about subclassing ConcurrentHashMap, but that seems to be impossible. It makes use of an inner final class HashEntry with default access, so although ConcurrentHashMap is not final, it's not extensible.
 
Which seems to mean that I have to fall back to implementing TickHolder as containing an old-school HashMap in order to write my conditional replace method.
 
So, the questions: am I right about the above? Have I (hopefully) missed something, whether obvious or subtle, which would lead to a different conclusion? I'd really like to be able to make use of that lovely striped locking mechanism here.

原文：https://stackoverflow.com/questions/1395010