标签: task-parallel-library

任务并行库(或PLINQ)是否考虑了其他过程?

特别是,我正在寻找使用TPL来启动(和等待)外部进程.在决定启动另一个任务之前,TPL是否会查看总机器负载(CPU和I/O)(因此 - 在我的情况下 - 另一个外部进程)?

例如:

我有大约100个需要编码或转码的媒体文件(例如从WAV到FLAC或从FLAC到MP3).编码是通过启动外部进程(例如FLAC.EXE或LAME.EXE)完成的.每个文件大约需要30秒.每个进程主要是CPU绑定的,但那里有一些I/O. 我有4个内核,所以最糟糕的情况(通过将解码器传输到编码器中进行代码转换)仍然只使用2个内核.我想做点什么:

Parallel.ForEach(sourceFiles,
    sourceFile =>
        TranscodeUsingPipedExternalProcesses(sourceFile));
Run Code Online (Sandbox Code Playgroud)

这将启动100个任务(因此200个外部进程竞争CPU)?或者它会看到CPU忙,一次只做2-3次?

task-parallel-library

14
推荐指数
1
解决办法
2163
查看次数

将使用backgroundworker的方法替换为async/tpl(.NET 4.0)

我的问题很多.从我看到.NET 4.5,我印象非常深刻.不幸的是我的所有项目都是.NET 4.0,我不考虑迁移.所以我想简化我的代码.

目前,我的大多数代码通常需要足够的时间来冻结屏幕,我会执行以下操作:

BackgroundWorker bd = new BackgroundWorker();
bd.DoWork += (a, r) =>
    {
        r.Result = ProcessMethod(r.Argument);
    };
bd.RunWorkerCompleted += (a, r)  =>
    {
        UpdateView(r.Result);
    };

bd.RunWorkerAsync(args);
Run Code Online (Sandbox Code Playgroud)

老实说,我已经厌倦了.当存在逻辑复杂的用户交互时,这成为一个大问题.

我想知道,如何简化这种逻辑?(请记住,我在.Net 4.0)我注意到谷歌的一些事情,但没有找到任何易于实施和适合我的需求.

我认为这个解决方案如下:

var foo = args as Foo;
var result = AsyncHelper.CustomInvoke<Foo>(ProcessMethod, foo);
UpdateView(result);

public static class AsyncHelper
{
    public static T CustomInvoke<T>(Func<T, T> func, T param) where T : class
    {
        T result = null;
        DispatcherFrame frame = new DispatcherFrame();
        Task.Factory.StartNew(() =>
        {
            result = func(param);
            frame.Continue = false; …
Run Code Online (Sandbox Code Playgroud)

wpf design-patterns pattern-matching backgroundworker task-parallel-library

14
推荐指数
1
解决办法
3958
查看次数

在数据流网络中使用BufferBlock <T>的好处

我想知道使用链接到一个或多个ActionBlocks的BufferBlock是否有好处,除了限制(使用BoundedCapacity),而不是直接发布到ActionBlock(只要不需要限制).

.net c# task-parallel-library tpl-dataflow

14
推荐指数
3
解决办法
9905
查看次数

实体框架与并行

背景

我有一个应用程序接收定期数据转储(XML文件)并使用Entity Framework 5(代码优先)将它们导入现有数据库.导入通过EF5而不是BULK INSERT或BCP进行,因为必须应用已存在于实体中的业务规则.

处理似乎是应用程序本身的CPU绑定(极快,启用了写缓存的磁盘IO子系统在整个过程中显示几乎为零的磁盘等待时间,而SQL Server显示的CPU时间不超过8%-10%).

为了提高效率,我使用TPL Dataflow构建了一个管道,其组件包括:

Read & Parse XML file
        |
        V
Create entities from XML Node
        |
        V
Batch entities (BatchBlock, currently n=200)
        |
        V
Create new DbContext / insert batched entities / ctx.SaveChanges()
Run Code Online (Sandbox Code Playgroud)

通过这样做,我看到性能大幅提升,但不能使CPU高于60%.

分析

怀疑某种资源争用,我使用VS2012 Profiler的资源争用数据(并发)模式运行该过程.

分析器显示52%的争用标记为句柄2的资源.钻进,我看到创建Handle 2最多争用的方法是

System.Data.Entity.Internal.InternalContext.SaveChanges()
Run Code Online (Sandbox Code Playgroud)

第二名,与SaveChanges()的争论大约是40%

System.Data.Entity.DbSet`1.Add(!0)
Run Code Online (Sandbox Code Playgroud)

问题

  • 我怎样才能弄清楚Handle 2究竟是什么(例如TPL的一部分,EF的一部分)?
  • EF限制调用将DbContext实例与单独的线程分开吗?似乎他们正在争夺一个共享资源.
  • 在这种情况下,我有什么办法可以改善并行性吗?

UPDATE

对于有问题的运行,调用SaveChanges的任务的最大并行度设置为12(我尝试了各种值,包括先前运行中的Unbounded).

更新2

微软的EF团队提供了反馈意见.请参阅我的答案以获取摘要.

parallel-processing profiling entity-framework task-parallel-library tpl-dataflow

14
推荐指数
1
解决办法
3809
查看次数

Parallel.ForEach不断产生新线程

当我在我的程序中使用Parallel.ForEach时,我发现有些线程似乎永远不会完成.事实上,它一直在反复产生新线程,这种行为是我没想到的,绝对不想要的.

我能够使用以下代码重现此行为,就像我的"真实"程序一样,它们都使用处理器和内存(.NET 4.0代码):

public class Node
{
    public Node Previous { get; private set; }

    public Node(Node previous)
    {
        Previous = previous;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        DateTime startMoment = DateTime.Now;
        int concurrentThreads = 0;

        var jobs = Enumerable.Range(0, 2000);
        Parallel.ForEach(jobs, delegate(int jobNr)
        {
            Interlocked.Increment(ref concurrentThreads);

            int heavyness = jobNr % 9;

            //Give the processor and the garbage collector something to do...
            List<Node> nodes = new List<Node>();
            Node current = null;
            for (int …
Run Code Online (Sandbox Code Playgroud)

.net c# concurrency parallel-extensions task-parallel-library

14
推荐指数
2
解决办法
8717
查看次数

使用心跳创建任务

我想运行一个具有" 心跳 " 的任务,该任务以特定的时间间隔继续运行,直到任务完成.

我在想这样的扩展方法效果很好:

public static async Task WithHeartbeat(this Task primaryTask, TimeSpan heartbeatInterval, Action<CancellationToken> heartbeatAction, CancellationToken cancellationToken)
Run Code Online (Sandbox Code Playgroud)

例如:

public class Program {
    public static void Main() {
        var cancelTokenSource = new CancellationTokenSource();
        var cancelToken = cancelTokenSource.Token;
        var longRunningTask = Task.Factory.StartNew(SomeLongRunningTask, cancelToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
        var withHeartbeatTask = longRunningTask.WithHeartbeat(TimeSpan.FromSeconds(1), PerformHeartbeat, cancelToken);
        withHeartbeatTask.Wait();
        Console.WriteLine("Long running task completed!");
        Console.ReadLine()
    }

    private static void SomeLongRunningTask() {
        Console.WriteLine("Starting long task");
        Thread.Sleep(TimeSpan.FromSeconds(9.5));
    }
    private static int _heartbeatCount = 0;
    private static void PerformHeartbeat(CancellationToken cancellationToken) …
Run Code Online (Sandbox Code Playgroud)

.net c# task-parallel-library async-await azureservicebus

14
推荐指数
1
解决办法
9794
查看次数

Task.Yield()与Task.Delay(0)

难道Delay(0)总要得到内联?根据我的经验,它确实:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication
{
    class Program
    {
        static async Task Test()
        {
            await Task.Yield();
            Console.WriteLine("after Yield(), thread: {0}", Thread.CurrentThread.ManagedThreadId);
            await Task.Delay(0);
            Console.WriteLine("after Delay(0), thread: {0}", Thread.CurrentThread.ManagedThreadId);
            await Task.Delay(100);
            Console.WriteLine("after Delay(100), thread: {0}", Thread.CurrentThread.ManagedThreadId);
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Main thread: {0}", Thread.CurrentThread.ManagedThreadId);
            Test().Wait();
        }
    }
}
Run Code Online (Sandbox Code Playgroud)

这是一个控制台应用程序,因此线程池用于继续.输出:

Main thread: 11
after Yield(), thread: 7
after Delay(0), thread: 7
after Delay(100), thread: 6
Run Code Online (Sandbox Code Playgroud)

.net c# multithreading task-parallel-library async-await

14
推荐指数
2
解决办法
6581
查看次数

是否有PLINQ的异步版本?

我想在一定程度的并行处理并行处理项目的同时对数据流执行查询.通常情况下,我会使用PLINQ,但我的工作项不是CPU绑定的,而是IO绑定的.我想使用异步IO.PLINQ不支持异步工作.

运行PLINQ样式查询的最聪明方法是什么,但使用异步工作项?


以下是该问题的更详细说明:

我的目标是以下面的查询逻辑描述的方式处理可能无限的"项目"流:

var items = new int[10]; //simulate data

var results =
 from x in items.AsParallel().WithDegreeOfParallelism(100)
 where Predicate(x)
 select ComputeSomeValue(x);

foreach (var result in results)
 PerformSomeAction(result);
Run Code Online (Sandbox Code Playgroud)

此查询只是真实查询的草图.现在我希望每个占位符函数都是异步的(返回a Task和内部基于异步IO).

请注意,可能存在的内容远远多于可以存储在内存中的项目.我还必须控制并行度以最大化底层网络和磁盘硬件.

这个问题不是关于多核的.它完全适用于只有一个CPU内核的机器,因为IO仍然可以从并行性中受益.想想慢速的Web服务调用等.

.net asynchronous plinq task-parallel-library

14
推荐指数
2
解决办法
1027
查看次数

任务排序和重新进入

我有以下场景,我认为这可能很常见:

  1. 有一个任务(一个UI命令处理程序)可以同步或异步完成.

  2. 命令的到达速度可能比处理它们的速度快.

  3. 如果命令已有待处理任务,则应对新命令处理程序任务进行排队并按顺序处理.

  4. 每个新任务的结果可能取决于前一个任务的结果.

应该遵守取消,但为了简单起见,我想将其排除在本问题的范围之外.此外,线程安全(并发)不是必需的,但必须支持重入.

这是我想要实现的基本示例(作为控制台应用程序,为简单起见):

using System;
using System.Threading.Tasks;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            var asyncOp = new AsyncOp<int>();

            Func<int, Task<int>> handleAsync = async (arg) =>
            {
                Console.WriteLine("this task arg: " + arg);

                //await Task.Delay(arg); // make it async

                return await Task.FromResult(arg); // sync
            };

            Console.WriteLine("Test #1...");
            asyncOp.RunAsync(() => handleAsync(1000));
            asyncOp.RunAsync(() => handleAsync(900));
            asyncOp.RunAsync(() => handleAsync(800));
            asyncOp.CurrentTask.Wait();

            Console.WriteLine("\nPress any key to continue to test #2...");
            Console.ReadLine();

            asyncOp.RunAsync(() =>
            {
                asyncOp.RunAsync(() => handleAsync(200)); …
Run Code Online (Sandbox Code Playgroud)

.net c# asynchronous task-parallel-library async-await

14
推荐指数
1
解决办法
3226
查看次数

将任务作为参数传递

我不确定这是否可行,所以我在这里:

我有一系列动作来执行多个

async Task MethodA(...)
{
    // some code
    // a call to specific Async IO bound method
    // some code
}
Run Code Online (Sandbox Code Playgroud)

还有MethodB(),MethodC()等,以及所有的具有完全相同的代码,除了呼叫到特定的异步IO绑定的方法.我试图找到一种方法将任务指针传递给方法,以便我们稍后可以在Method()中执行它.

我目前正在做的是:

private async Task Method(Func<Task<Entity>> func)
{
    // some code
    var a = await task.Run(func);
    // some code
}

var task = async () => await CallToIOBoundTask(params);
Method(task);
Run Code Online (Sandbox Code Playgroud)

但是,此代码每次都会提取一个新线程,这对于IO绑定任务不是必需的,应该避免使用.

那么,有没有办法重构代码,以便不使用ThreadPool线程?目标是拥有这样的代码:

private async Task Method(Task<Entity> task)
{
    // some code
    var a = await task;
    // some code
}
Run Code Online (Sandbox Code Playgroud)

同样重要的是要提到不同的IO调用具有不同的方法签名.此外,任务可以开始仅在Method()正文中执行,而不是之前执行.

.net c# task-parallel-library async-await .net-4.5

14
推荐指数
1
解决办法
9242
查看次数