同步对 ConcurrentMap 中给定键的访问

Question

我经常想要访问（并且可能添加/删除）给定 ConcurrentMap 的元素，以便一次只有一个线程可以访问任何单个键。最好的方法是什么？同步密钥本身不起作用：其他线程可能通过 equal 实例访问相同的密钥。

如果答案仅适用于 guava MapMaker 构建的地图，那就足够了。

Answer 1

在这里查看一个简单的解决方案 基于简单 Java 名称的锁？

编辑：这解决方案从解锁到锁定具有明确的先发生关系。然而，现在已撤回的下一个解决方案却没有。 ConcurrentMap javadoc 太轻，无法保证这一点。

---

（撤回）如果你想将你的映射重新用作锁池，

private final V LOCK = ...; // a fake value
// if a key is mapped to LOCK, that means the key is locked
ConcurrentMap<K,V> map = ...;

V lock(key)
    V value;  
    while( (value=map.putIfAbsent(key, LOCK))==LOCK )
        // another thread locked it before me
        wait();
    // now putIfAbsent() returns a real value, or null
    // and I just sucessfully put LOCK in it
    // I am now the lock owner of this key
    return value; // for caller to work on

// only the lock owner of the key should call this method
unlock(key, value)
    // I put a LOCK on the key to stall others
    // now I just need to swap it back with the real value
    if(value!=null) 
        map.put(key, value);
    else // map doesn't accept null value
        map.remove(key)
    notifyAll();

test()
    V value = lock(key);

    // work on value

    // unlock. 
    // we have a chance to specify a new value here for the next worker
    newValue = ...; // null if we want to remove the key from map
    unlock(key, newValue); // in finally{}

这会很混乱，因为我们将映射重新用于两个不同的目的。最好将锁池作为一个单独的数据结构，而将map简单地作为kv存储。

Answer 2

    private static final Set<String> lockedKeys = new HashSet<>();

    private void lock(String key) throws InterruptedException {
        synchronized (lockedKeys) {
            while (!lockedKeys.add(key)) {
                lockedKeys.wait();
            }
        }
    }

    private void unlock(String key) {
        synchronized (lockedKeys) {
            lockedKeys.remove(key);
            lockedKeys.notifyAll();
        }
    }

    public void doSynchronouslyOnlyForEqualKeys(String key) throws InterruptedException {
        try {
            lock(key);

            //Put your code here.
            //For different keys it is executed in parallel.
            //For equal keys it is executed synchronously.

        } finally {
            unlock(key);
        }
    }

• key 不仅可以是“String”，还可以是任何具有正确重写的“equals”和“hashCode”方法的类。
• try-finally - 非常重要 - 即使您的操作抛出异常，您也必须保证在操作后解锁等待线程。
• 如果您的后端分布在多个服务器/JVM上，它将无法工作。

Answer 3

难道你不能创建自己的类来扩展并发映射吗？
重写 get(Object key) 方法，以便它检查请求的密钥对象是否已被另一个线程“检出”？

您还必须在并发映射中创建一个新方法，将项目“返回”到映射，以便它们再次可供另一个线程使用。