Java 中的并发字节数组访问，使用尽可能少的锁

Question

我正在尝试减少分段数据的锁定对象的内存使用量。请参阅我的问题here 和here。或者只是假设您有一个字节数组，并且每 16 个字节可以（反）序列化为一个对象。让我们称其为行长为 16 字节的“行”。现在，如果您从写入线程修改这样的行并从多个线程读取，则需要锁定。如果您的字节数组大小为 1MB (1024*1024)，这意味着 65536 行和相同数量的锁。

这有点太多了，而且我需要更大的字节数组，我想将它减少到与线程数大致成比例的东西。我的想法是创建一个

ConcurrentHashMap<Integer, LockHelper> concurrentMap;

其中Integer 是行索引，在线程“进入”一行之前，它会在此映射中放置一个锁定对象（从this answer 得到这个想法）。但无论我怎么想，我都找不到真正线程安全的方法：

// somewhere else where we need to write or read the row
LockHelper lock1 = new LockHelper();
LockHelper lock = concurrentMap.putIfAbsent(rowIndex, lock1);
lock.addWaitingThread(); // is too late
synchronized(lock) {
  try { 
      // read or write row at rowIndex e.g. writing like
      bytes[rowIndex/16] = 1;
      bytes[rowIndex/16 + 1] = 2;
      // ...
  } finally {
     if(lock.noThreadsWaiting())
        concurrentMap.remove(rowIndex);
  }
}

你认为有可能使这个线程安全吗？

我觉得这看起来很像 concurrentMap.compute 构造（例如，参见 this answer），或者我什至可以使用这种方法吗？

map.compute(rowIndex, (key, value) -> {
    if(value == null)
       value = new Object();
    synchronized (value) {
        // access row
        return value;
    }
});
map.remove(rowIndex);

我们已经知道计算操作是原子的，因此值和“同步”是否必要？

// null is forbidden so use the key also as the value to avoid creating additional objects
ConcurrentHashMap<Integer, Integer> map = ...;

// now the row access looks really simple:
map.compute(rowIndex, (key, value) -> {
    // access row
    return key;
});
map.remove(rowIndex);

顺便说一句：自从我们在 Java 中使用此计算时。从1.8开始？在 JavaDocs 中找不到这个

更新：我发现了一个非常相似的问题here 使用 userIds 而不是 rowIndices，请注意，该问题包含一个示例，其中包含多个问题，例如缺少 final，在 @987654340 中调用 lock @-clause 并且没有缩小地图。似乎也有 a library JKeyLockManager 用于此目的，但 I don't think it is thread-safe。

更新 2：解决方案似乎非常简单，因为 Nicolas Filotto 指出了如何避免删除：

map.compute(rowIndex, (key, value) -> {
    // access row
    return null;
});

所以这确实是内存密集度较低，但synchronized 的简单段锁定在my scenario 中至少快 50%。

Answer 1

值和synchronized 是必需的吗？ 知道计算操作是原子的吗？

我确认在这种情况下不需要添加synchronized 块，因为compute 方法是原子完成的，如ConcurrentHashMap#compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 的Javadoc 中所述，自Java 8 以来已添加BiFunction ，我引用：

尝试计算指定键及其当前键的映射 映射值（如果没有当前映射，则为 null）。 整个 方法调用以原子方式执行。一些尝试更新 其他线程在此映射上的操作可能会被阻塞，而 计算正在进行中，所以计算应该很短并且 简单，并且不得尝试更新此 Map 的任何其他映射。

如果您让 BiFunction 始终返回 null 以原子方式删除密钥，那么您尝试使用 compute 方法实现的目标可能是完全原子的，这样一切都将原子地完成。

map.compute(
    rowIndex, 
    (key, value) -> {
        // access row here
        return null;
    }
);

这样，您将完全依赖 ConcurrentHashMap 的锁定机制来同步您对行的访问。