虽然我将在这里谈论的代码我在F#中编写,但它基于.NET 4框架,而不是特别依赖于F#的任何特殊性(至少看起来如此!).
我的磁盘上有一些数据,我应该从网络更新,将最新版本保存到磁盘:
type MyData =
{ field1 : int;
field2 : float }
type MyDataGroup =
{ Data : MyData[];
Id : int }
// load : int -> MyDataGroup
let load dataId =
let data = ... // reads from disk
{ Data = data;
Id = dataId }
// update : MyDataGroup -> MyDataGroup
let update dg =
let newData = ... // reads from the network and process
// newData : MyData[]
{ dg with …Run Code Online (Sandbox Code Playgroud) .net parallel-processing f# parallel-extensions task-parallel-library
我需要快速遍历一棵树,我想并行完成.我宁愿使用并行扩展而不是手动旋转一堆线程.
我当前的代码看起来像这样:
public void Traverse(Node root)
{
var nodeQueue = new Queue<Node>();
nodeQueue.Enqueue(root);
while (nodeQueue.Count!=0)
{
var node = nodeQueue.Dequeue();
if (node.Property = someValue) DoSomething(node);
foreach (var node in node.Children)
{
nodeQueue.Enqueue(node);
}
}
}
Run Code Online (Sandbox Code Playgroud)
我真的希望Parallel.ForEach有一个Parallel.While模拟.我遇到了Stephen Toub关于使用Parallel.ForEach实现Parallels Parallel的文章.如果正确读取它仍然无法工作,因为我正在改变我试图迭代的队列.
我是否需要使用任务工厂和递归(这有风险吗?)?还是有一些我忽略的简单解决方案?
编辑:@svick
该树有超过250,000个节点.现在最大深度是14个节点,包括根.
根目录下有大约500个节点,之后的平衡具有相当随机的分布.我很快就会得到更好的分布统计数据.
@Enigmativity:
是的,许多用户同时修改了树,但我通常会为树或子树提供共享读锁,或允许脏读.
对node.Children的调用可以被认为是原子的.
DoSomething实际上是几个代理之一,对于一些昂贵的操作,我可能会收集节点的快照列表并在遍历之外处理它们.
我意识到我应该看一般情况(遍历的子树而不是整个树.)为此,我在树的每个节点上运行遍历并查看总时间.
我为每个遍历算法使用了Parallel.ForEach(nodes,Traverse),其中节点包含所有~250k节点.这模拟(某种程度上)许多用户同时请求许多不同的节点.
00256ms广度优先顺序
00323ms广度优先连续工作(我将静态计数器增加为"工作")
01495ms Kirks第一个回答
01143ms Svicks第二个答案
00000ms Recursive Single Threaded在60s后没有完成
00000ms电子书的答案在60年代后没有完成
@Enigma,我想我可能会以某种方式搞砸你的算法,因为它似乎应该更快.
结果令我惊讶的是至少可以说.为了让自己相信编译器并没有神奇地优化遍历,我不得不在广度第一顺序中添加一些工作.
对于头部的单次遍历,并行化第一级仅具有最佳性能.但几乎没有,这个数字有所改善,因为我向第二级添加了更多节点(2000而不是500).
我特别想要在一个或另一个中编写一些信号处理算法,或者两者兼而有之.
表现并不是一个大问题,表达意图的清晰度更为重要.
我想要实现以下'Blocks'并组成它们:
我认为Rx可以被认为是'Linq-to-streams',而TPL是对并发的抽象.我还得到Rx在内部使用TPL来管理其异步位,并且TPL数据流为TPL增加了可组合性.
所以两者都是异步的,都是可组合的,都是相当高的水平(Rx更多).通常和上面的信号处理项目应该在哪里使用?
signal-processing dataflow task-parallel-library system.reactive tpl-dataflow
所以我有一些代码
Task.Factory.StartNew(() => this.listener.Start()).ContinueWith(
(task) =>
{
if (task.IsCompleted)
{
this.status = WorkerStatus.Started;
this.RaiseStatusChanged();
this.LogInformationMessage("Worker Started.");
}
});
Run Code Online (Sandbox Code Playgroud)
当我测试时,我正在模拟所有依赖对象(namley this.listener.Start()).问题是测试在ContinueWith被调用之前完成执行.当我调试时,由于我单步执行代码的额外延迟,它被称为罚款.
那么我怎么能 - 从不同程序集中的测试代码 - 确保代码在我的测试遇到其断言之前运行?
我可以使用Thread.Sleep ......但这似乎是一种真正的hacky方式.
我想我正在寻找Thread.Join的Task版本.
我正在尝试编写一些代码,这些代码将使Web服务并行调用多个不同的服务器,因此TPL似乎是一个明显的选择.
只有我的一个Web服务调用将返回我想要的结果,而其他所有调用都不会.我正试图找出一种有效的方法,Task.WaitAny当Task匹配条件的第一个返回时,只有解锁.
我尝试过,WaitAny但无法确定过滤器的位置.我到目前为止:
public void SearchServers()
{
var servers = new[] {"server1", "server2", "server3", "server4"};
var tasks = servers
.Select(s => Task<bool>.Factory.StartNew(server => CallServer((string)server), s))
.ToArray();
Task.WaitAny(tasks); //how do I say "WaitAny where the result is true"?
//Omitted: cancel any outstanding tasks since the correct server has been found
}
private bool CallServer(string server)
{
//... make the call to the server and return the result ...
}
Run Code Online (Sandbox Code Playgroud)
编辑:快速澄清,以防上面有任何混淆.我正在尝试执行以下操作:
Task进行检查我在使用时遇到了一个问题,Task.Factory.StartNew并试图捕获exception被抛出的问题.在我的应用程序中,我有一个长期运行的任务,我想封装在一个Task.Factory.StartNew(.., TaskCreationOptions.LongRunning);
但是,当我使用时,没有捕获异常Task.Factory.StartNew.然而,当我使用时Task.Run,它正如我所期望的那样工作,我认为它只是一个包装器Task.Factory.StartNew(根据例如这篇MSDN文章).
这里提供了一个工作示例,不同之处在于在使用时将异常写入控制台Task.Run,但在使用时不会Factory.StartNew.
我的问题是:
如果我有一个LongRunning可以抛出异常的任务,我应该如何在调用代码中处理它们?
private static void Main(string[] args)
{
Task<bool> t = RunLongTask();
t.Wait();
Console.WriteLine(t.Result);
Console.ReadKey();
}
private async static Task<bool> RunLongTask()
{
try
{
await RunTaskAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
return false;
}
Console.WriteLine("success");
return true;
}
private static Task RunTaskAsync()
{
//return Task.Run(async () =>
// {
// throw new Exception("my exception");
// }); …Run Code Online (Sandbox Code Playgroud) 在连续链中传播异常的正确方法是什么?
t.ContinueWith(t2 =>
{
if(t2.Exception != null)
throw t2.Exception;
/* Other async code. */
})
.ContinueWith(/*...*/);
t.ContinueWith(t2 =>
{
if(t2.IsFaulted)
throw t2.Exception;
/* Other async code. */
})
.ContinueWith(/*...*/);
t.ContinueWith(t2 =>
{
if(t2.Exception != null)
return t2;
/* Other async code. */
})
.ContinueWith(/*...*/);
t.ContinueWith(t2 =>
{
if(t2.IsFaulted)
return t2;
/* Other async code. */
})
.ContinueWith(/*...*/);
t.ContinueWith(t2 =>
{
t2.Wait();
/* Other async code. */
})
.ContinueWith(/*...*/);
t.ContinueWith(t2 =>
{
/* Other async code. */
}, TaskContinuationOptions.NotOnFaulted) // Don't …Run Code Online (Sandbox Code Playgroud) 例
private void Start(object sender, RoutedEventArgs e)
{
int progress = 0;
for (;;)
{
System.Threading.Thread.Sleep(1);
progress++;
Logger.Info(progress);
}
}
Run Code Online (Sandbox Code Playgroud)
如果我想要Start(),建议的方法是什么(TAP或TPL或BackgroundWorker或Dispatcher或其他)
返回的方法Task有两个报告错误的选项:
调用者是否应该期望两种类型的错误报告,或者是否存在将任务行为限制为第二个选项的某些标准/协议?
例:
class PageChecker {
Task CheckWebPage(string url) {
if(url == null) // Argument check
throw Exception("Bad URL");
if(!HostPinger.IsHostOnline(url)) // Some other synchronous check
throw Exception("Host is down");
return Task.Factory.StartNew(()=> {
// Asynchronous check
if(PageDownloader.GetPageContent(url).Contains("error"))
throw Exception("Error on the page");
});
}
}
Run Code Online (Sandbox Code Playgroud)
处理这两种类型看起来很丑陋:
try {
var task = pageChecker.CheckWebPage(url);
task.ContinueWith(t =>
{
if(t.Exception!=null)
ReportBadPage(url);
});
}
catch(Exception ex) {
ReportBadPage(url);
}
Run Code Online (Sandbox Code Playgroud)
使用async/await可能有所帮助,但有没有异步支持的纯.NET 4解决方案?
假设我在一个类中有一个成员变量(具有原子读/写数据类型):
bool m_Done = false;
Run Code Online (Sandbox Code Playgroud)
后来我创建了一个将其设置为true的任务:
Task.Run(() => m_Done = true);
Run Code Online (Sandbox Code Playgroud)
我不在乎什么时候m_Done将被设置为true.我的问题是,我是否有C#语言规范和任务并行库的保证,如果我从不同的线程访问它,最终m_Done将成立?
例:
if(m_Done) { // Do something }
Run Code Online (Sandbox Code Playgroud)
我知道使用锁会引入必要的内存障碍,m_Done将在以后显示为true.此外,我可以在设置变量时使用Volatile.Write,在读取时使用Volatile.Read.我看到很多代码以这种方式编写(没有锁或易失性),我不确定它是否正确.
请注意,我的问题不是针对C#或.Net的特定实现,而是针对规范.如果在x86,x64,Itanium或ARM上运行,我需要知道当前代码的行为是否相似.
c# multithreading volatile memory-model task-parallel-library
c# ×8
.net ×2
exception ×2
.net-4.0 ×1
asynchronous ×1
continuation ×1
dataflow ×1
f# ×1
memory-model ×1
moq ×1
nunit ×1
tap ×1
task ×1
taskfactory ×1
tpl-dataflow ×1
unit-testing ×1
volatile ×1
wpf ×1