当必须锁定每个列表元素时，多个线程应如何访问列表

本文关键字：何访问 列表 访问 线程 锁定 列表元素 | 更新日期: 2023-09-27 18:36:17

我有一个"模块"类的列表，List<Module> modules .这些模块都包含自己的公共对象，以便在访问数据时用作锁。假设我有几个线程在随机时间对这些模块执行处理。目前，我让每个线程按顺序对模块执行处理，如下所示：

foreach (Module module in modules)
{
    lock (module.Locker)
    {
        //Do stuff
    }
}

到目前为止，这工作正常，但我感觉有很多不必要的等待。例如，如果两个线程一个接一个地启动，但第一个线程正在执行繁重的处理，而第二个线程没有执行繁重的处理，则第二个线程将不得不等待每个模块，而第一个线程正在执行其处理。

那么问题来了：是否有一种"适当"或"最有效"的方法来锁定列表中的元素？我打算这样做：

foreach (Module module in modules.Randomize())
{
    lock (module.Locker)
    {
        //Do stuff
    }
}

其中"Randomize（）"只是一个以随机顺序返回列表元素的扩展方法。但是，我想知道是否有比随机更好的方法？

当必须锁定每个列表元素时，多个线程应如何访问列表

假设锁内的工作很大并且存在严重的争用。我引入了创建新List<T>并从中删除项目的额外开销。

public void ProcessModules(List<Module> modules)
{
    List<Module> myModules = new List<Module>(modules);//Take a copy of the list
    int index = myModules.Count - 1;
    while (myModules.Count > 0)
    {
        if (index < 0)
        {
            index = myModules.Count - 1;
        }
        Module module = myModules[index];
        if (!Monitor.TryEnter(module.Locker))
        {
            index--;
            continue;
        }
        try
        {
            //Do processing module
        }
        finally
        {
            Monitor.Exit(module.Locker);
            myModules.RemoveAt(index);
            index--;
        }
    }
}

此方法的作用是获取传入的模块的副本，然后尝试获取锁，如果无法获取它（因为另一个线程拥有它），它会跳过并继续前进。完成列表后，它会再次查看另一个线程是否已释放锁，如果没有，则再次跳过它并继续前进。这个循环一直持续到我们处理列表中的所有模块。

这样，我们就不会等待任何争用的锁，我们只是继续处理未被另一个线程锁定的模块。

lock代表 Monitor.Enter ，您可以使用Monitor.TryEnter来检查是否已获取 lock，并以某种方式跳过此元素并尝试获取另一个元素。

如果多个线程正在处理相同的有序项目列表，则会有开销，因此Randomize的想法似乎是一个不错的选择（除非与处理本身相比，重新排序的成本很高，或者可以在处理时更改列表等）。

完全不同的可能性是为每个线程准备队列（从列表中），其方式不会有交叉等待（或等待将被最小化）。结合Monitor.TryEnter这应该是一个最终的解决方案。不幸的是，我不知道如何准备这样的队列，也不知道如何跳过处理队列项目，留给你=P。

以下是我的意思的片段：

foreach(var item in list)
    if(!item.Processed && Monitor.TryEnter(item.Locker))
        try
        {
            ... // do job
            item.Processed = true;
        }
        finally
        {
            Monitor.Exit(item.Locker))
        }

不确定我是否完全遵循，但是据我所知，您的目标是定期对每个模块执行操作，并且您希望使用多个线程，因为这些内容很耗时。如果是这种情况，我会让单个线程定期检查所有模块，并让该线程使用 TPL 来分散工作负载，如下所示：

Parallel.ForEach(modules, module =>
{
    lock(module.Locker)
    {
    }
});

顺便说一句，关于锁的指导是你锁定的对象应该是私有的，所以我可能会改为做这样的事情：

Parallel.ForEach(modules, module => module.DoStuff());
// In the module implementation
private readonly object _lock = new object();
public void DoStuff()
{
    lock (this._lock)
    {
        // Do stuff here
    }
}

即每个模块都应该是线程安全的，并负责自己的锁定。

相关文章：