使“枚举时修改”集合线程安全

Question

我想创建一个可以在枚举时修改的线程安全集合。

示例ActionSet 类存储Action 处理程序。它具有将新处理程序添加到列表的Add 方法和枚举并调用所有收集的操作处理程序的Invoke 方法。预期的工作场景包括非常频繁的枚举，在枚举时偶尔会进行修改。

如果您在枚举未结束时使用Add 方法修改普通集合，则会引发异常。

有一个简单但缓慢的解决方案：在枚举之前克隆集合：

class ThreadSafeSlowActionSet {
    List<Action> _actions = new List<Action>();

    public void Add(Action action) {
        lock(_actions) {
            _actions.Add(action);
        }
    }

    public void Invoke() {
        lock(_actions) {
            List<Action> actionsClone = _actions.ToList();
        }
        foreach (var action in actionsClone ) {
            action();
        }
    }
}

这个解决方案的问题是枚举开销，我希望枚举非常快。

我创建了一个相当快的“递归安全”集合，即使在枚举时也允许添加新值。如果在枚举主 _actions 集合时添加新值，这些值将添加到临时 _delta 集合而不是主集合。完成所有枚举后，_delta 值将添加到 _actions 集合中。如果在枚举主 _actions 集合时添加一些新值（创建 _delta 集合），然后再次重新输入 Invoke 方法，我们必须创建一个新的合并集合（_actions + _delta）并用它替换_actions。

所以，这个集合看起来“递归安全”，但我想让它成为线程安全的。我认为我需要使用Interlocked.* 构造、System.Threading 中的类和其他同步原语来使这个集合线程安全，但我不知道如何做到这一点。

如何使这个集合线程安全？

class RecursionSafeFastActionSet {
    List<Action> _actions = new List<Action>(); //The main store
    List<Action> _delta; //Temporary buffer for storing added values while the main store is being enumerated
    int _lock = 0; //The number of concurrent Invoke enumerations

    public void Add(Action action) {
        if (_lock == 0) { //_actions list is not being enumerated and can be modified
            _actions.Add(action);
        } else { //_actions list is being enumerated and cannot be modified
            if (_delta == null) {
                _delta = new List<Action>();
            }
            _delta.Add(action); //Storing the new values in the _delta buffer
        }
    }

    public void Invoke() {
        if (_delta != null) { //Re-entering Invoke after calling Add:  Invoke->Add,Invoke
            Debug.Assert(_lock > 0);
            var newActions = new List<Action>(_actions); //Creating a new list for merging delta
            newActions.AddRange(_delta); //Merging the delta
            _delta = null;
            _actions = newActions; //Replacing the original list (which is still being iterated)
        }
        _lock++;
        foreach (var action in _actions) {
            action();
        }
        _lock--;
        if (_lock == 0 && _delta != null) {
            _actions.AddRange(_delta); //Merging the delta
            _delta = null;
        }
    }
}

更新：添加了ThreadSafeSlowActionSet 变体。

Answer 1

因为我实际上还需要从集合中删除项目，所以我最终使用的实现是基于重写的 LinkedList，它在删除/插入时锁定相邻节点并且不会抱怨在枚举过程中发生了变化。 我还添加了Dictionary 以使元素搜索更快。

Answer 2

一种更简单的方法（例如，ConcurrentBag 使用）是让GetEnumerator() 在集合内容的快照上返回一个枚举器。在您的情况下，这可能看起来像：

public IEnumerator<Action> GetEnumerator()
{
    lock(sync)
    {
        return _actions.ToList().GetEnumerator();
    }
}

如果您这样做，则不需要 _delta 字段及其增加的复杂性。

Answer 3

这是为线程安全而修改的类：

class SafeActionSet
{
    Object _sync = new Object();
    List<Action> _actions = new List<Action>(); //The main store
    List<Action> _delta = new List<Action>();   //Temporary buffer for storing added values while the main store is being enumerated
    int _lock = 0; //The number of concurrent Invoke enumerations

    public void Add(Action action)
    {
        lock(sync)
        {
            if (0 == _lock)
            { //_actions list is not being enumerated and can be modified
                _actions.Add(action);
            }
            else
            { //_actions list is being enumerated and cannot be modified
                _delta.Add(action); //Storing the new values in the _delta buffer
            }
        }
    }

    public void Invoke()
    {
        lock(sync)
        {
            if (0 < _delta.Count)
            { //Re-entering Invoke after calling Add:  Invoke->Add,Invoke
                Debug.Assert(0 < _lock);
                var newActions = new List<Action>(_actions); //Creating a new list for merging delta
                newActions.AddRange(_delta); //Merging the delta
                _delta.Clear();
                _actions = newActions; //Replacing the original list (which is still being iterated)
            }
            ++_lock;
        }
        foreach (var action in _actions)
        {
            action();
        }
        lock(sync)
        {
            --_lock;
            if ((0 == _lock) && (0 < _delta.Count))
            {
                _actions.AddRange(_delta); //Merging the delta
                _delta.Clear();
            }
        }
    }
}

我做了一些其他的调整，原因如下：

• 反转 IF 表达式首先具有常量值，所以如果我执行 错字并输入“=”而不是“==”或“！=”等，编译器将 立即告诉我错字。 （：我养成了一个习惯，因为我的大脑和手指经常不同步:)
• 预分配 _delta，并调用 .Clear() 而不是将其设置为 null， 因为我觉得它更容易阅读。
• 各种lock(_sync) {...} 为您提供all 实例变量访问的线程安全。 :( 除了您在枚举本身中访问 _action 之外。):