我应该何时以及如何使用 ConcurrentHashMap 的额外同步？

Question

在使用 ConcurrentHashMap 时，我需要知道何时应该在我的代码中添加一些同步块。假设我有一个类似的方法：

private static final ConcurrentMap<String, MyObjectWrapper> myObjectsCache = new ConcurrentHashMap<>(CACHE_INITIAL_CAPACITY);

    public List<MyObject> aMethod(List<String> ids, boolean b) {
        List<MyObject> result = new ArrayList<>(ids.size());
        for (String id : ids) {
            if (id == null) {
                continue;
            }
            MyObjectWrapper myObjectWrapper = myObjectsCache.get(id);
            if (myObjectWrapper == null) {
                continue;
            }
            if (myObjectWrapper.getObject() instanceof MyObjectSub) {
                ((MyObjectSub) myObjectWrapper.getObject()).clearAField();
                myObjectWrapper.getObject().setTime(System.currentTimeMillis());
            }
            result.add(myObjectWrapper.getObject());
            if (b) {
                final MyObject obj = new MyObject(myObjectWrapper.getObject());
                addObjectToDb(obj);
            }
        }
        return result;
    }

我应该如何有效地使这个方法并发？ 我认为“get”是安全的，但是一旦我从缓存中获取值并更新缓存对象的字段 - 可能会出现问题，因为另一个线程可以获得相同的包装器并尝试更新相同的底层对象......我应该添加同步？如果是这样，那么我应该从“get”同步到循环迭代结束还是整个循环？

当需要对循环内的映射键/值等进行更多操作时，也许有人可以分享一些更具体的正确和有效使用 ConcurrentHashMap 的指南等......

我将不胜感激。

编辑： 这个问题的一些背景： 我目前正在重构生产代码中的一些 dao 类，其中一些类使用 HashMaps 来缓存从数据库中检索到的数据。所有使用缓存（用于写入或读取）的方法都将其全部内容放在同步（缓存）块中（安全吗？）。我在并发方面没有太多经验，我很想利用这个机会学习。我天真地将 HashMaps 更改为 ConcurrentHashMaps，现在想在需要的地方删除同步块。所有缓存都用于写入和读取。所提出的方法基于我已更改的方法之一，现在我正在尝试了解何时以及在何种程度上同步。 clearAField 方法只是更改包装的 POJO 对象的其中一个字段的值，然后 addObjectToDb 尝试将该对象添加到数据库中。

其他示例是重新填充缓存：

public void findAll() throws SQLException{
    // get data from database into a list
    List<Data> data=getAllDataFromDatabase();
    cacheCHM.clear();
    cacheCHM.putAll(data);
} 

在这种情况下，我应该将 clear 和 putAll 放在 synchronize(cacheCHM) 块中，对吗？

我尝试查找并阅读一些关于正确有效地使用 CHM 的帖子/文章，但大多数都处理单个操作，没有循环等。我发现最好的是： http://www.javamadesoeasy.com/2015/04/concurrenthashmap-in-java.html

Answer 1

你没有提到你期望在你的应用中发生什么并发，所以我假设你有多个线程调用aMethod，没有别的。

您只需调用一次 ConcurrentHashMap：myObjectsCache.get(id)，这很好。事实上，由于没有将数据写入您的 objectCache [参见上面的假设]，您甚至不需要 ConcurrentHashMap！任何不可变的集合都可以。你最后有一个可疑的行：addObjectToDb(obj)，这个方法也会影响你的缓存吗？如果是这样，它仍然是安全的（可能我们必须看到方法才能确定），但你肯定需要 ConcurentHashMap。

危险就在你改变对象的地方，这里：

myObjectWrapper.getObject().clearAField();
myObjectWrapper.getObject().setTime(System.currentTimeMillis());

多个线程可以同时在同一个对象上调用这些方法。在不知道这些方法的作用的情况下，我们不能说这是否安全。如果这些方法都标记为已同步，或者如果您注意确保这些方法同时运行是安全的，那么您就可以了（但请注意，这些方法的运行顺序可能与您可能直观地期望的不同！ )。如果您不那么小心，则可能会损坏数据。

Answer 2

线程安全和缓存的更好方法是使用immutable objects。如果 MyObjectSub 类是不可变的，这就是它的样子[不知道为什么需要包装器 - 我会完全忽略它]：

//Provided by way of example. You should consider generating these 
//using http://immutables.github.io/ or similar
public class MyImmutableObject {
    //If all members are final primitives or immutable objects 
    //then this class is threadsafe.
    final String field;
    final long time;

    public MyImmutableObject(String field, long time) {
        this.field = field;
        this.time = time;
    }

    public MyImmutableObject clearField() {
        //Since final fields can never be changed, our only option is to 
        //return a copy.
        return new MyImmutableObject("", this.time);
    }

    public MyImmutableObject setTime(long newtime) {
        return new MyImmutableObject(this.field, newtime);
    }
}

如果你的对象是不可变的，那么线程安全就简单多了。你的方法看起来像这样：

public List<Result> typicialCacheUsage(String key) {
    MyImmutableObject obj = myObjectsCache.get(key);

    obj = obj.clearField();
    obj = obj.setTime(System.currentTimeMillis());

    //If you need to put the object back in the cache you can do this:
    myObjectsCache.put(key, obj);

    List<Result> res = generateResultFromObject(obj);
    return res;
}