.NET Dictionary仅写入加锁、无锁读取是否线程安全？

核心风险：无锁读取可能引发结构损坏与异常 #

你担忧的情况确实存在风险——当写入线程执行Add操作（尤其是触发Dictionary内部扩容时），无锁的读取线程可能访问到处于中间状态的哈希表结构，进而抛出异常、返回错误结果，甚至导致程序崩溃。

为什么会出问题？ #

Dictionary底层基于哈希表实现，插入操作可能触发两种关键内部修改：

• 链表节点插入：当多个键哈希冲突时，会在对应桶的链表中添加新节点。若读取线程此时遍历该链表，可能拿到不完整的链表结构，返回错误值或触发空引用异常。
• 哈希表扩容：当Dictionary元素数量达到负载因子阈值时，会重新分配更大的内部数组，将所有现有元素重新哈希并拷贝到新数组。这个过程中，旧数组与新数组处于交替状态，无锁读取可能访问到已部分废弃的内存，或读到半拷贝的元素集合，直接引发InvalidOperationException、索引越界，甚至更严重的内存访问错误。

你的场景中可接受旧数据，但这种结构损坏带来的混乱（如返回完全错误的值、程序崩溃）是不可接受的，当前实现存在明确隐患。

针对你场景的改进方案 #

结合你“可接受旧数据，但不能接受异常/混乱”的需求，有几种简单可行的改进方式：

1. 读取操作也加锁（最简单直接）

把读取逻辑也放入lock块，彻底避免读写冲突：

public class Example 
{
    private readonly object _sync = new object();
    private readonly Dictionary<string, string> _dictionary = new Dictionary<string, string>();

    public void Write(string key, string value)
    {
        lock(_sync)
        {
            if (!_dictionary.ContainsKey(key))
                _dictionary.Add(key, value);
        }
    }

    public string Read(string key)
    {
        lock(_sync)
        {
            _dictionary.TryGetValue(key, out var value);
            return value;
        }
    }
}

这种方式会有轻微性能损耗，但完全安全，实现成本最低。

2. 用读写锁平衡性能与安全性

如果读取频率远高于写入，可使用ReaderWriterLockSlim，允许多个线程同时读取，仅写入时独占锁：

public class Example 
{
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private readonly Dictionary<string, string> _dictionary = new Dictionary<string, string>();

    public void Write(string key, string value)
    {
        _lock.EnterWriteLock();
        try
        {
            if (!_dictionary.ContainsKey(key))
                _dictionary.Add(key, value);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }

    public string Read(string key)
    {
        _lock.EnterReadLock();
        try
        {
            _dictionary.TryGetValue(key, out var value);
            return value;
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }
}

3. 原子替换副本（无锁读取）

若写入频率极低，可在写入时创建字典副本，修改后原子替换原引用，读取时直接访问当前引用的副本，完全避免锁竞争：

public class Example 
{
    private volatile Dictionary<string, string> _dictionary = new Dictionary<string, string>();

    public void Write(string key, string value)
    {
        // 创建副本并修改
        var newDict = new Dictionary<string, string>(_dictionary);
        if (!newDict.ContainsKey(key))
            newDict.Add(key, value);
        // 原子替换原引用
        Interlocked.Exchange(ref _dictionary, newDict);
    }

    public string Read(string key)
    {
        // 读取当前引用的副本，无锁
        var currentDict = _dictionary;
        currentDict.TryGetValue(key, out var value);
        return value;
    }
}

这种方式读取完全无锁，写入开销较高，适合写入少、读取极多的场景。

关键提醒 #

哪怕只做插入不做删除，Dictionary的内部扩容操作依然会改变底层结构，无锁读取的风险始终存在，不能因操作简单就忽略线程安全问题。

内容的提问来源于stack exchange，提问作者Skary