鉴于延迟执行，我试图了解并行性如何使用 PLINQ 工作。这是一个简单的例子。
string[] words = { "believe", "receipt", "relief", "field" };
bool result = words.AsParallel().Any(w => w.Contains("ei"));
使用 LINQ，我希望执行达到“收据”值并返回 true，而不执行其余值的查询。
如果我们并行执行此操作，则“relief”的评估可能在“receipt”的结果返回之前就已开始。但是一旦查询知道“receipt”会导致一个真实的结果，其他线程是否会立即yield？
就我而言，这很重要，因为“任何”测试可能非常昂贵，而且我希望释放处理器以执行其他任务。
我正在使用 List.AsParallel().ForAll() PLINQ 实现。在循环内部，如果我发现某个条件成功，我希望循环立即脱离 ForAll() 循环。我怎样才能实现它？
这是示例代码。
using System;
using System.Collections.Generic;
using System.Linq;
namespace Basics
{
class Program
{
class Family
{
public int SNo { get; set; }
public string Name { get; set; }
}
static List<Family> families = null;
static Program()
{
families = new List<Family>()
{
new Family(){SNo = 10, Name="Richard"},
new Family(){SNo = 33, Name="Xio Fung"},
new Family(){SNo = 10, Name="Sean"},
new Family(){SNo = 10, Name="Andrea"},
new Family(){SNo = 20, Name="Bjorn"},
new Family(){SNo = 20, …在LINQ查询中,我可以正确地(如:编译器不会抱怨)调用.AsParallel(),如下所示:
(from l in list.AsParallel() where <some_clause> select l).ToList();
或者像这样:
(from l in list where <some_clause> select l).AsParallel().ToList();
究竟有什么区别？
从官方文档来看,我几乎总是看到第一种方法,所以我认为这是要走的路.
今天,我试图自己运行一些基准测试,结果令人惊讶.这是我运行的代码:
var list = new List<int>();
var rand = new Random();
for (int i = 0; i < 100000; i++)
list.Add(rand.Next());
var treshold= 1497234;
var sw = new Stopwatch();
sw.Restart();
var result = (from l in list.AsParallel() where l > treshold select l).ToList();
sw.Stop();
Console.WriteLine($"call .AsParallel() before: {sw.ElapsedMilliseconds}");
sw.Restart();
result = (from l in list where …在以前版本的Parallel Extensions中,您可以设置线程数:
enumerable.AsParallel(numberOfThreads)
但是现在再也没有超载了.现在该怎么办？
这是场景:
我有一个正在运行的Windows服务.OnStart()它设置了一个调用函数的计时器(让我们调用它ProcessEvent()).里面的代码ProcessEvent是一个关键部分,所以只有一个线程可以执行以下操作:
private void ProcessEvent(object sender, ElapsedEventArgs e)
{
lock(lockObj)
{
string[] list = GetList();
Parallel.ForEach(list, item => { ProcessItem(item) });
}
}
ProcessItem 可能需要很长时间.
现在当服务停止时,我OnStop()当前只是停止并处理计时器.但是我注意到即使在服务停止后仍然存在仍在运行的线程ProcessItem().
那么我怎样才能杀死这个程序产生的所有正在运行的线程(主要是由那些产生的线程,Parallel.ForEach还有任何等待锁定的线程ProcessEvent)？
我知道,如果我自己创建了线程,我可以将其设置isBackground为true,并且当进程死亡时它将全部被杀死,但我不会手动创建这些线程.
我正在调用一个调用数据库的worker方法,然后迭代并生成并行处理的返回值.为了防止它锤击数据库,我在那里有一个Thread.Sleep来暂停执行到DB.但是,这似乎是在Parallel.ForEach中仍然发生的阻塞执行.实现这一目标以防止阻塞的最佳方法是什么？
private void ProcessWorkItems()
{
_cancellation = new CancellationTokenSource();
_cancellation.Token.Register(() => WorkItemRepository.ResetAbandonedWorkItems());
Task.Factory.StartNew(() =>
Parallel.ForEach(GetWorkItems().AsParallel().WithDegreeOfParallelism(10), workItem =>
{
var x = ItemFactory(workItem);
x.doWork();
}), _cancellation.Token);
}
private IEnumerable<IAnalysisServiceWorkItem> GetWorkItems()
{
while (!_cancellation.IsCancellationRequested)
{
var workItems = WorkItemRepository.GetItemList(); //database call
workItems.ForEach(item =>
{
item.QueueWorkItem(WorkItemRepository);
});
foreach (var item in workItems)
{
yield return item;
}
if (workItems.Count == 0)
{
Thread.Sleep(30000); //sleep this thread for 30 seconds if no work items.
}
}
yield break;
}
编辑:我改变它以包括答案,它仍然没有像我期待的那样工作.我将.AsParallel().WithDegreeOfParallelism(10)添加到GetWorkItems()调用中.当我认为即使基本线程正在睡眠时Parallel仍应继续执行,我的期望是否正确？
示例:我有15个项目,它迭代并抓取10个项目并启动它们.当每个人完成时,它会从GetWorkItems请求另一个,直到它试图要求第16个项目.此时它应该停止尝试获取更多项目,但应继续处理项目11-15,直到完成.是应该如何并行工作？因为它目前没有这样做.它目前正在做的是当它完成6时,它会锁定后续的10个仍然在Parallel.ForEach中运行.
嗨,谢谢你的期待!
我有一项计算任务需要大量时间或并行计算.
具体来说,我需要循环遍历大约50个图像的列表,Base64对它们进行编码,然后计算每个新编码项目与包含大约2000个Base64字符串编码图像的XML文件中的值之间的Levenshtein距离,以便找到字符串.具有最小Lev的XML文件.与基准字符串的距离.
常规foreach循环工作,但速度太慢,所以我选择使用PLINQ来利用我的Core i7多核处理器:
Parallel.ForEach(candidates, item => findImage(total,currentWinner,benchmark,item));
任务开始非常出色,高速奔跑,但后来我得到了一个"内存不足"的例外.
我正在使用C#,.NET 4,Forms App.
我如何调整我的PLINQ代码,以便我没有可用的内存耗尽？
这是调用PLINQ的方法foreach:
private void btnGo_Click(object sender, EventArgs e)
{
XDocument doc = XDocument.Load(@"C:\Foo.xml");
var imagesNode = doc.Element("images").Elements("image"); //Each "image" node contains a Base64 encoded string.
string benchmark = tbData.Text; //A Base64 encoded string.
IEnumerable<XElement> candidates = imagesNode;
currentWinner = 1000000; //Set the "Current" low score to a million and bubble lower scores into it's place iteratively.
Parallel.ForEach(candidates, i => { …我的代码做的很简单
列表已经有元素.我在列表中有大约25000个元素(我希望有更多元素),每个元素都很小(DateTime).
List<DateTime> newList = new List<DateTime>();
Parallel.ForEach(list, l => newlist.Add(new DateTime(l.Ticks + 5000)));
也就是说,基于每个元素,我正在创建新元素并将它们添加到不同的列表中.但是,这似乎不是一个好的编程方法.我打这个例外一些时间,但不是每次.
IndexOutOfRangeException : {"Index was outside the bounds of the array."}
我们可以使用Parallel.ForEach()将元素添加到列表中吗？如果是,为什么我会遇到错误？如果不是,为什么？
我正在使用它们的整数id排序对象列表OrderBy.我有一些具有相同id的对象,需要排序才能保持稳定.
根据微软的文档,并行化OrderBy并不稳定,但有一种实现方法可以使其稳定.但是,我找不到这样的例子.
var list = new List<pair>() { new pair("a", 1), new pair("b", 1), new pair("c", 2), new pair("d", 3), new pair("e", 4) };
var newList = list.AsParallel().WithDegreeOfParallelism(4).OrderBy<pair, int>(p => p.order);
private class pair {
private String name;
public int order;
public pair (String name, int order) {
this.name = name;
this.order = order;
}
}
我想用PLINQ方法AsParallel()重写这个Parallel.For循环.据我所知,AsParallel()需要将整个序列传递给它,例如创建数组A,然后调用A.AsParallel().ForAll或A.AsParallel().选择.有没有办法让AsParallel()在一个范围内工作 - 在这种情况下,从低到高？
for k = 2 to m+n do
let low = max 1 (k-m)
let high = min (k-1) n
Parallel.For(low, high + 1, (fun j ->