C# 单态上的并行ForEach'；s存储字段

我使用此单例模式实现了一个度量存储：

// Thread-safe 'Lazy' singleton for metrics collection
public sealed class MetricsService
{
    private static readonly MetricsService instance = new MetricsService();

    static MetricsService()
    {
    }

    private MetricsService()
    {
        Storage = new List<DeviceMetrics>();

        Requests = new List<RequestMetrics>();
        Subruns = new List<SubrunMetrics>();
        Runs = new List<RunMetrics>();
    }

    public static MetricsService Instance
    {
        get
        {
            return instance;
        }
    }
    //

//用于度量集合的线程安全的“惰性”单例
公共密封式计量服务
{
私有静态只读MetricsService实例=新MetricsService（）；
静态度量服务（）
{
}
私人度量衡服务（）
{
存储=新列表（）；
请求=新列表（）；
子运行=新列表（）；
运行=新列表（）；
}
公共静态MetricsService实例
{
得到
{
返回实例；
}
}
//

它有一些像这样的方法：

    // Get metrics for a single component in specific device
    public List<SubrunMetrics> GetComponentMetrics(string deviceName, string componentName)
    {
        var device = GetDeviceMetrics(deviceName);

        if (device != null)
        {
            // get list of subruns
            var subrunsList = new List<SubrunMetrics>();

            foreach (var run in device.RunMetrics)
            {
                run.SubrunMetrics.ForEach(subrunsList.Add);
            }

            // generate new list of subruns related to component
            var results = new List<SubrunMetrics>();

            foreach (var subrun in subrunsList)
            {
                if (subrun.ComponentName == componentName)
                {
                    results.Add(subrun);
                }
            }

            if (results.Count > 0)
            {
                return results;
            }
        }

        return null;
    }
    //

//获取特定设备中单个组件的指标
公共列表GetComponentMetrics（string deviceName、string componentName）
{
var设备=GetDeviceMetrics（deviceName）；
如果（设备！=null）
{
//获取子运行的列表
var subrunsList=新列表（）；
foreach（var run-in-device.RunMetrics）
{
run.SubrunMetrics.ForEach（subrunsList.Add）；
}
//生成与组件相关的子运行的新列表
var results=新列表（）；
foreach（subrunsList中的var subrun）
{
if（subrun.ComponentName==ComponentName）
{
结果。添加（子运行）；
}
}
如果（results.Count>0）
{
返回结果；
}
}
返回null；
}
//

现在，我想知道这里是否可以使用多线程，让我们以这种方式假设：

        ...

        if (device != null)
        {
            // get list of subruns
            var subrunsList = new List<SubrunMetrics>();

            Parallel.ForEach(device.RunMetrics, (run) =>
                                                {
                                                    run.SubrunMetrics.ForEach(subrunsList.Add);
                                                }
                            );

            // generate new list of subruns related to component
            var results = new List<SubrunMetrics>();

            Parallel.ForEach(subrunsList, (subrun) =>
                                          {
                                              results.Add(subrun);
                                          }
                            );

。。。
如果（设备！=null）
{
//获取子运行的列表
var subrunsList=新列表（）；
Parallel.ForEach（device.RunMetrics，（run）=>
{
run.SubrunMetrics.ForEach（subrunsList.Add）；
}
);
//生成与组件相关的子运行的新列表
var results=新列表（）；
Parallel.ForEach（subrunsList，（subrun）=>
{
结果。添加（子运行）；
}
);

---

我在MSDN上读过一些关于这方面的资料，但我仍然不确定这个线程安全懒惰的东西是否真的能让它变得安全，然后它会加快速度吗？

你可以使用它使它成为一个可行的线程安全解决方案，但它是否会更快取决于项目的数量。这是一个很大的数字，我相信你可以节省大量的时间nt时间。

如果您正在修改实例字段/属性，那么不，这不是线程安全的。但是，我认为没有理由使用这些并行循环，因为只有一个示例-

run.SubrunMetrics.ForEach（subrunsList.Add）

不是线程安全的，因为两个线程可能同时调用

subrunsList.Add

。而

List

在该场景中不是线程安全的。