标签: task-parallel-library

Parallel.Foreach产生太多线程的方式

问题

虽然我将在这里谈论的代码我在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

13
推荐指数
3
解决办法
7719
查看次数

C#中的并行树遍历

我需要快速遍历一棵树,我想并行完成.我宁愿使用并行扩展而不是手动旋转一堆线程.

我当前的代码看起来像这样:

   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).

c# parallel-processing tree-traversal task-parallel-library

13
推荐指数
1
解决办法
5143
查看次数

TPL数据流优于反应性扩展(Rx)的用例有哪些

我特别想要在一个或另一个中编写一些信号处理算法,或者两者兼而有之.

表现并不是一个大问题,表达意图的清晰度更为重要.

我想要实现以下'Blocks'并组成它们:

  • 滤波器(FIR和IIR)
  • 相位检测器
  • 集成
  • 搅拌机
  • 函数发生器
  • PLL(使用上面的构建块)

我认为Rx可以被认为是'Linq-to-streams',而TPL是对并发的抽象.我还得到Rx在内部使用TPL来管理其异步位,并且TPL数据流为TPL增加了可组合性.

所以两者都是异步的,都是可组合的,都是相当高的水平(Rx更多).通常和上面的信号处理项目应该在哪里使用?

signal-processing dataflow task-parallel-library system.reactive tpl-dataflow

13
推荐指数
1
解决办法
2472
查看次数

单元测试代码,使用Task.Factory.StartNew().ContinueWith()

所以我有一些代码

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版本.

c# nunit unit-testing moq task-parallel-library

13
推荐指数
1
解决办法
7441
查看次数

具有指定结果的任务并行库WaitAny

我正在尝试编写一些代码,这些代码将使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)

编辑:快速澄清,以防上面有任何混淆.我正在尝试执行以下操作:

  1. 对于每个服务器,启动a Task进行检查
  2. 或者,等到服务器返回true(最多只有1个服务器将返回true) …

c# task-parallel-library

13
推荐指数
1
解决办法
4850
查看次数

Task.Run和Task.Factory.StartNew之间的异常处理

我在使用时遇到了一个问题,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)

c# exception task-parallel-library taskfactory

13
推荐指数
1
解决办法
5946
查看次数

在连续链中传播异常的正确方法是什么?

在连续链中传播异常的正确方法是什么?

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)

c# exception task task-parallel-library continuation

13
推荐指数
1
解决办法
1706
查看次数

在WPF应用程序中执行后台任务

例

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或其他)

  1. 不要阻止ui线程
  2. 可以提供进度报告
  3. 可以取消
  4. 支持多线程和多核

c# wpf multithreading tap task-parallel-library

13
推荐指数
2
解决办法
3万
查看次数

应该返回Task的方法抛出异常吗?

返回的方法Task有两个报告错误的选项:

  1. 立刻抛出异常
  2. 返回将以异常结束的任务

调用者是否应该期望两种类型的错误报告,或者是否存在将任务行为限制为第二个选项的某些标准/协议?

例:

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解决方案?

.net c# asynchronous .net-4.0 task-parallel-library

13
推荐指数
1
解决办法
3690
查看次数

C#变量新鲜

假设我在一个类中有一个成员变量(具有原子读/写数据类型):

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

13
推荐指数
1
解决办法
732
查看次数