在 Parallel.Invoke 中更新同一对象的不同属性是线程安全的吗？

首先应该提到的是Property1，在您的示例中，Property2和Property3在技​​术上称为字段，而不是属性。

TestResult在Parallel.Invoke操作成功完成后，您的示例对于实例的完整性是完全安全的。它的所有字段都将被初始化，并且它们的值将由当前线程可见（但不一定对在 完成之前已经运行的其他线程可见Parallel.Invoke）。

另一方面，如果Parallel.Invoke失败，那么TestResult实例可能最终会被部分初始化。

如果Property1,Property2和Property3实际上是properties，那么您的代码的线程安全性将取决于在set这些属性的访问器后面运行的代码。如果此代码是微不足道的，例如set { _property1 = value; }，那么您的代码将是安全的。

作为旁注，建议您Parallel.Invoke使用合理的MaxDegreeOfParallelism. 否则，您将获得Parallel该类的默认行为，即使ThreadPool.

TestResult testResult = new();

Parallel.Invoke(new ParallelOptions()
{ MaxDegreeOfParallelism = Environment.ProcessorCount },
    () => testResult.Property1 = GetProperty1Value(),
    () => testResult.Property2 = GetProperty2Value(),
    () => testResult.Property3 = GetProperty3Value()
);

替代方案：如果您想知道如何在TestResult不依赖闭包和副作用的情况下初始化实例，这是一种方法：

var taskFactory = new TaskFactory(new ConcurrentExclusiveSchedulerPair(
    TaskScheduler.Default, Environment.ProcessorCount).ConcurrentScheduler);

var task1 = taskFactory.StartNew(() => GetProperty1Value());
var task2 = taskFactory.StartNew(() => GetProperty2Value());
var task3 = taskFactory.StartNew(() => GetProperty3Value());

Task.WaitAll(task1, task2, task3);

TestResult testResult = new()
{
    Property1 = task1.Result,
    Property2 = task2.Result,
    Property3 = task3.Result,
};

属性的值临时存储在各个Task对象中，最后在所有任务完成后，在当前线程上将它们分配给属性。因此，这种方法消除了有关构造TestResult实例完整性的所有线程安全考虑。

但是有一个缺点：Parallel.Invoke使用当前线程，并且也调用它的一些操作。相反，该Task.WaitAll方法将浪费地阻塞当前线程，让其ThreadPool完成所有工作。

只是为了好玩：我试图编写一个ObjectInitializer工具，它应该能够并行计算对象的属性，然后按顺序（线程安全）分配每个属性的值，而无需手动管理一堆分散的Task变量。这是我想出的API：

var initializer = new ObjectInitializer<TestResult>();
initializer.Add(() => GetProperty1Value(), (x, v) => x.Property1 = v);
initializer.Add(() => GetProperty2Value(), (x, v) => x.Property2 = v);
initializer.Add(() => GetProperty3Value(), (x, v) => x.Property3 = v);
TestResult testResult = initializer.RunParallel(degreeOfParallelism: 2);

不是很漂亮，但至少它是简洁的。该Add方法为一个属性添加元数据，并RunParallel执行并行和顺序工作。这是实现：

public class ObjectInitializer<TObject> where TObject : new()
{
    private readonly List<Func<Action<TObject>>> _functions = new();

    public void Add<TProperty>(Func<TProperty> calculate,
        Action<TObject, TProperty> update)
    {
        _functions.Add(() =>
        {
            TProperty value = calculate();
            return source => update(source, value);
        });
    }

    public TObject RunParallel(int degreeOfParallelism)
    {
        TObject instance = new();
        _functions
            .AsParallel()
            .AsOrdered()
            .WithDegreeOfParallelism(degreeOfParallelism)
            .Select(func => func())
            .ToList()
            .ForEach(action => action(instance));
        return instance;
    }
    public TObject Run() => RunParallel(Environment.ProcessorCount);
}

它使用PLINQ而不是Parallel类。

我会用吗？可能不是。主要是因为并行初始化对象的需要并不经常出现，而且在这种罕见的情况下必须维护如此晦涩的代码似乎有点过分了。我可能会采用肮脏和副作用的Parallel.Invoke方法。:-)