事件处理程序异步触发引发逻辑异常，Lock无效如何解决？

问题原因 #

你遇到的问题核心是共享资源的并发访问未被正确同步，即使加了锁仍出现异常，具体原因可能有以下几点：

1. 锁的范围不完整：如果锁只覆盖了字典的操作，而数组array、变量len的读写未被包含在锁块内，两个线程会交叉操作这些资源。比如第一个线程还没更新array[1]，第二个线程已经读取了array[1]的旧值，后续用旧值查询字典自然找不到对应key。
2. 线程可见性问题：普通数组和字典没有线程可见性保障，第一个线程更新array[1]后，第二个线程可能读取到CPU缓存中的旧值，而非最新的内存值，导致判断逻辑出错。
3. 循环变量len的共享问题：如果len是共享变量，两次事件触发时len的值可能被修改，导致第二次循环的起始索引不符合预期（比如本应从0开始，实际从1开始）。

优化解决方案 #

1. 完整锁覆盖所有共享资源操作 #

将数组、字典、len的所有读写操作都放入同一个锁块内，确保同一时间只有一个线程能操作这些资源：

// 定义全局锁对象
private readonly object _syncLock = new object();

void someEventHandler(object sender, EventArgs e)
{
    lock (_syncLock)
    {
        // 在锁内读取len，避免读取旧值
        int currentLen = len;
        for (int i = currentLen; i >= 0; i--)
        {
            var currentKey = array[i];
            if (dictionary.ContainsKey(currentKey))
            {
                // 删除旧key
                dictionary.Remove(currentKey);
                // 执行你的处理逻辑
                // 生成新key
                var newKey = /* 你的新key生成逻辑 */;
                // 添加新key到字典
                dictionary.Add(newKey, /* 对应的值 */);
                // 更新数组
                array[i] = newKey;
            }
            else
            {
                // 未找到key的处理逻辑
            }
        }
    }
}

2. 使用线程安全集合+数组同步 #

用ConcurrentDictionary替代普通Dictionary（它本身提供线程安全的增删查操作），同时用锁保护数组的读写：

private readonly ConcurrentDictionary<YourKeyType, YourValueType> _threadSafeDict = new ConcurrentDictionary<YourKeyType, YourValueType>();
private readonly object _arrayLock = new object();

void someEventHandler(object sender, EventArgs e)
{
    lock (_arrayLock)
    {
        int currentLen = len;
        for (int i = currentLen; i >= 0; i--)
        {
            var currentKey = array[i];
            if (_threadSafeDict.TryRemove(currentKey, out var value))
            {
                // 执行处理逻辑
                var newKey = /* 新key生成逻辑 */;
                _threadSafeDict.TryAdd(newKey, /* 新值 */);
                array[i] = newKey;
            }
            else
            {
                // 未找到key的处理逻辑
            }
        }
    }
}

3. 串行化事件处理（彻底避免并发） #

如果业务上不需要并行处理事件，可以将事件请求放入队列，用单线程串行处理，从根本上消除并发冲突：

private readonly Queue<EventArgs> _eventQueue = new Queue<EventArgs>();
private readonly object _queueLock = new object();
private bool _isProcessingQueue = false;

void someEventHandler(object sender, EventArgs e)
{
    lock (_queueLock)
    {
        _eventQueue.Enqueue(e);
    }
    // 确保只有一个线程处理队列
    if (!_isProcessingQueue)
    {
        ProcessEventQueue();
    }
}

void ProcessEventQueue()
{
    lock (_queueLock)
    {
        if (_isProcessingQueue) return;
        _isProcessingQueue = true;
    }

    try
    {
        while (true)
        {
            EventArgs currentEvent;
            lock (_queueLock)
            {
                if (_eventQueue.Count == 0)
                {
                    _isProcessingQueue = false;
                    break;
                }
                currentEvent = _eventQueue.Dequeue();
            }

            // 执行原有的处理逻辑，单线程无需额外锁
            int currentLen = len;
            for (int i = currentLen; i >= 0; i--)
            {
                var currentKey = array[i];
                if (dictionary.ContainsKey(currentKey))
                {
                    dictionary.Remove(currentKey);
                    // 处理逻辑
                    var newKey = /* 新key生成逻辑 */;
                    dictionary.Add(newKey, /* 新值 */);
                    array[i] = newKey;
                }
                else
                {
                    // 未找到key的处理逻辑
                }
            }
        }
    }
    finally
    {
        lock (_queueLock)
        {
            _isProcessingQueue = false;
        }
    }
}

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