特别是,我正在寻找使用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次?
我的问题很多.从我看到.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
我想知道使用链接到一个或多个ActionBlocks的BufferBlock是否有好处,除了限制(使用BoundedCapacity),而不是直接发布到ActionBlock(只要不需要限制).
背景
我有一个应用程序接收定期数据转储(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)
问题
UPDATE
对于有问题的运行,调用SaveChanges的任务的最大并行度设置为12(我尝试了各种值,包括先前运行中的Unbounded).
更新2
微软的EF团队提供了反馈意见.请参阅我的答案以获取摘要.
parallel-processing profiling entity-framework task-parallel-library tpl-dataflow
当我在我的程序中使用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
我想运行一个具有" 心跳 " 的任务,该任务以特定的时间间隔继续运行,直到任务完成.
我在想这样的扩展方法效果很好:
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) 难道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) 我想在一定程度的并行处理并行处理项目的同时对数据流执行查询.通常情况下,我会使用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服务调用等.
我有以下场景,我认为这可能很常见:
有一个任务(一个UI命令处理程序)可以同步或异步完成.
命令的到达速度可能比处理它们的速度快.
如果命令已有待处理任务,则应对新命令处理程序任务进行排队并按顺序处理.
每个新任务的结果可能取决于前一个任务的结果.
应该遵守取消,但为了简单起见,我想将其排除在本问题的范围之外.此外,线程安全(并发)不是必需的,但必须支持重入.
这是我想要实现的基本示例(作为控制台应用程序,为简单起见):
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) 我不确定这是否可行,所以我在这里:
我有一系列动作来执行多个
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 ×7
c# ×6
async-await ×4
asynchronous ×2
tpl-dataflow ×2
.net-4.5 ×1
concurrency ×1
plinq ×1
profiling ×1
wpf ×1