使用 Parallel.ForEach 在最小值中选择最小值

Question

我对 C#、

Parallel.ForEach

和 .NET 总体来说还是新手。我想要并行化涉及数千个位置的搜索。对于每个位置，我计算大圆距离。这是我想扩展到不同核心的计算。我的问题是，如果我只有 one 线程局部变量，如本 MSDN TPL 示例 所示，我该如何执行此操作？对于结果，我查看了

Interlocked

，看到了它的选项

Add

、

CompareExchange

、

Decrement

、

Exchange

、

Increment

和

Read

，但我不只是添加、递增、递减，或测试是否相等。我想通过并行运行的多个线程返回具有最短总体距离的对象。我的直觉告诉我这应该很容易，我应该能够创建一些包裹

Location

和距离的小对象，但是我如何从每个线程中捕获最佳答案并然后选择其中最短的距离？这是非并行版本：

Location findClosestLocation(Location myLocation, List<Location> allLocations)
{
  double closest = double.MaxValue;
  Location closestLoc = null;
  foreach (Location aLoc in allLocations)
  {
    if (aLoc != myLocation)
    {
      double d = greatCircle(myLocation, aLoc);
      if (d < closest)
      {
        closest = d;
        closestLoc = aLoc;
      }
    }
  }
  return closestLoc;
}

我确实看到了一篇DDJ博客文章，它似乎提供了很好的建议，但我想知道这是否是最好的建议。我看到作者循环遍历数组，想知道是否没有更实用的方法来执行此操作。在函数世界中，我会使用

map

、

lambda

和

min

。

Answer 1

这里最简单的选择是切换到 PLINQ：

Location findClosestLocation(Location myLocation, List<Location> allLocations)
{
     return allLocations
               .AsParallel()
               .Min(location => greatCircle(myLocation, location));
}

---

话虽这么说，这基本上只是“并行构造的聚合”。如果您想坚持使用 Parallel 类，您有几个选择。一种选择是使用锁定在块内自行同步。我不推荐这样做，因为它会损害你的整体表现。 更好的选择是使用提供本地状态的

Parallel.ForEach

方法。他们允许你将其重写为：

Location findClosestLocation(Location myLocation, List<Location> allLocations)
{
  double closest = double.MaxValue;
  Location closestLoc = null;
  object sync = new object();

  Parallel.ForEach<Location, Tuple<double,Location>(
      allLocations,
      () => new Tuple(double.MaxValue, null),
      (location, loopState, localState) =>
      {
          double d = greatCircle(myLocation, aLoc);
          if (d < localState.Item1)
              return new Tuple(d, aLoc);
          else
              return localState;
      },
      localState =>
      {
          lock(sync)
          {
              if (localState.Item1 < closest)
              {
                  closest = localState.Item1;
                  closestLoc = localState.Item2;
              }
          }
      }
  );
  return closestLoc;
}

我在我的博客上详细介绍了使用

本地状态进行聚合

。这基本上将操作更改为每个线程一个锁定操作，而不是每个处理元素一个锁定，因此您获得的吞吐量比简单的锁定解决方案高得多。