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

Question

我是C#Parallel.ForEach,和.NET的新手.我想并行化涉及数千个位置的搜索.对于每个位置,我计算大圆距离.这是我想要传播到不同核心的计算.我的问题是,如果我只有一个线程局部变量,我该怎么做呢,就像在这个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;
}

我在我的博客上详细介绍了使用本地状态进行聚合.这基本上将操作更改为每个线程一个锁定操作,而不是每个处理元素一个锁定,因此您获得比天真锁定解决方案更高的吞吐量.