为什么密钥被 IdentityHashMap 删除

Question

我知道IdentityHashMap不是线程安全的数据结构，所以下面的测试失败并不令人意外。 话虽如此，我对非并发和非同步映射不是线程安全的理解是，在 map 中的值的放置与值的获取之间没有发生关系，因此接收的线程来自缓存的值，如果该值有发布问题，则不需要查看所有字段。

但是我无法理解 Map 即使它不是线程安全的也如何丢失值。 见下面的代表，

import org.junit.jupiter.api.RepeatedTest;

import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

class IdentityHashmapTest {

    static class Key {
        final String description;

        Key(String description) {
            this.description = description;
        }

        @Override
        public String toString() {
            return "Key{" +
                    "description='" + description + '\'' +
                    '}';
        }

        @Override
        public boolean equals(Object o) {
            return this == o;
        }

        @Override
        public int hashCode() {
            return Objects.hash(description);
        }
    }

    @RepeatedTest(100)
    void testConcurrency() throws InterruptedException {
        final Map<Key, Integer> map = new IdentityHashMap<>();
        Key mainKey = new Key("main");
        map.put(mainKey, 1);
        ExecutorService executor = Executors.newFixedThreadPool(4);
        assertNotNull(map.get(mainKey));
        for (int i = 0; i <= 5; i++) {
            executor.submit(() -> {
                for (int j = 1; j <= 5; j++) {
                    map.put(new Key("random"), ThreadLocalRandom.current().nextInt());
                }
            });
        }
        executor.shutdown();
        assertTrue(executor.awaitTermination(30, TimeUnit.SECONDS));
        assertNotNull(map.get(mainKey));
    }
}

我什至在对IdentityHashMap进行并发更新之前就插入mainKey ，但是在关闭所有线程之后，我可以看到在某些情况下该值已从 map 中消失。 请注意，并非所有 100 次RepeatedTest调用都失败，但平均有 10-20 次调用失败。

我怀疑这可能是因为调整大小，因为如果我用一个大的expectedMaxSize初始化 IdentityHashMap，所有测试都会通过。 我还看到在 IdentityHashMap 中对调整大小进行了特殊处理，这增加了我的怀疑。

我想了解值是如何从 IdentityHashMap 中删除的。 我已经知道问题的解决方法（即使用像ConcurrentHashMap这样的线程安全数据结构，我有兴趣了解这种不一致的确切根本原因。

Answer 1

你有两个线程在没有协调的情况下处理同一个结构。 每个线程都认为操作 map 是安全的，但是它想要并采取相应的行动。 当两个线程都这样做时，所有的赌注都没有了。 没有“预期的行为”，除了您应该期望它会中断。

map 不仅仅是一个无限大的数据包，您可以不断向其中塞入更多数据。 随着它的发展，它需要重组。 插入不仅仅是将某个数组中的 null 元素设置为具有非空值。 它可能会导致 map 中所有内容的完全重组。

如果您有 2 个线程同时尝试进行此重组，那么即使当前未插入这些线程中的任何一个的键也可能丢失 go 似乎是合理的。

如果您在 map 上设置了明确的默认大小，那么我认为您会看到更少的失败。 这不是解决方案 - 解决方案是使用线程安全的实现 - 但这将证明稀疏 Map 将进行更少的重组，这应该会减少错误的频率（尽管不会消除它们）。

final Map<Key, Integer> map = new IdentityHashMap<>(1_000);

Answer 2

这是IdentityHashMap::resize的代码片段

        Object[] oldTable = table;
        ...
        Object[] newTable = new Object[newLength];
        ...
        for (int j = 0; j < oldLength; j += 2) {
            Object key = oldTable[j];
            if (key != null) {
                Object value = oldTable[j+1];
>>>>>>>>>>>>>>  oldTable[j] = null;
>>>>>>>>>>>>>>  oldTable[j+1] = null;
                int i = hash(key, newLength);
                while (newTable[i] != null)
                    i = nextKeyIndex(i, newLength);
                newTable[i] = key;
                newTable[i + 1] = value;
            }
        }
        table = newTable;

它在复制到新数组时将旧数组中的值设置为 null，然后将新数组指定为该字段。

你有 5 个线程同时执行此操作，所以有时会发生这种情况：

1. 线程 A 和 B 同时开始调整大小，因此它们看到对oldTable的相同引用。 线程 A 成功地从oldTable中复制了“main”并清空了旧值。 线程 B 有点落后，因此不能再看到“main”，因为线程 A 已将其删除。
2. 线程 A 将其newTable分配给包含“main”的字段，然后线程 B 将其自己的newTable分配给该字段，但由于#1，它不包含“main”。
3. 现在 map 不包含“主要”。