标签: task-parallel-library

(如何)TPL使用(CLR)线程池?

我正在研究任务并行库,我在某处读到TPL实际上使用了CLR-Level的线程池机制.我找不到任何确认此信息的文章.我知道,TPL为每个线程都有任务队列,并使用一些特殊的工作窃取算法进行平衡.据我所知,它为每个处理器创建一个线程.自.NET 4以来,线程池开始使用TPL的任务对象.

我无法理解TPL如何使用线程池.线程池模式状态,工作项排队,线程池中的空闲线程从此队列中获取一个.然而,TPL将项目(任务)存储到线程队列中,并且如果需要的话,工作窃取工作......因此,完全不同.我的错误在哪里?

额外的问题:由于这是我的第一个Stack Overflow问题,我不确定它是否合适.是吗?

.net threadpool task-parallel-library

12
推荐指数
1
解决办法
4743
查看次数

当应用程序退出时,我如何等待异步操作完成?

如果用户执行操作(例如删除项目),则会立即将其从UI中删除,然后使用TPL在后台线程上将其从数据库中删除.问题是如果用户在后台线程完成之前退出应用程序,该项目实际上永远不会被删除.

在关闭应用程序之前是否存在等待异步操作完成的标准方法?

我的异步调用看起来像这样:

if (MyObjectList.Contains(obj)) MyObjectList.Remove(obj);
Task.Factory.StartNew(() => DAL<MyEntities>.DeleteObject(obj));
Run Code Online (Sandbox Code Playgroud)

更新

这是我最后的代码.我很高兴看到它能够正常工作,但是如果我能改进的话,请告诉我.我还有很多东西需要学习:)

public partial class App : Application
{
    private List<Task> _backgroundTasks = new List<Task>();

    public App()
    {
        EventSystem.Subscribe<TaskStartedMessage>((e) =>
        {
            _backgroundTasks.Add(e.Task);
        });

        EventSystem.Subscribe<TaskEndedMessage>((e) =>
        {
            if (_backgroundTasks.Contains(e.Task))
                _backgroundTasks.Remove(e.Task);
        });
    }

    protected override void OnExit(ExitEventArgs e)
    {
        Task.WaitAll(_backgroundTasks.Where(p => !p.IsCompleted).ToArray(), 30000);

        base.OnExit(e);
    }
}
Run Code Online (Sandbox Code Playgroud)

在开始一项重要的后台任务时,我正在使用以下语法:

var task = Task.Factory.StartNew(() => DAL<MyEntities>.DeleteObject(obj));
EventSystem.Publish<TaskStartedMessage>(new TaskStartedMessage(task));
await task;
EventSystem.Publish<TaskEndedMessage>(new TaskEndedMessage(task));
Run Code Online (Sandbox Code Playgroud)

我正在使用AsyncCTP for await/ async,而Microsoft Prism EventAggregator用于事件系统.

c# wpf asynchronous task-parallel-library

12
推荐指数
1
解决办法
5987
查看次数

.NET 4.0的Task类 - Promise接口?

这个Task类有一个promise接口,比如jQuery的deferred promise方法吗?

.net task-parallel-library

12
推荐指数
3
解决办法
3169
查看次数

如何从WinForms中的子任务更新UI

我有一个简单的小winforms应用程序,通过TPL任务在另一个线程上执行长时间运行的进程.在这个漫长的运行过程中,我想更新UI(进度条或其他内容).有没有办法这样做而不需要.ContinueWith()?

public partial class Form1 : Form
{
    private Task _childTask;

    public Form1()
    {
        InitializeComponent();

        Task.Factory.StartNew(() =>
        {
            // Do some work
            Thread.Sleep(1000);

            // Update the UI
            _childTask.Start();

            // Do more work
            Thread.Sleep(1000);
        });

        _childTask = new Task((antecedent) =>
        {
            Thread.Sleep(2000);
            textBox1.Text = "From child task";
        }, TaskScheduler.FromCurrentSynchronizationContext());


    }
}
Run Code Online (Sandbox Code Playgroud)

执行此代码我得到无处不在的异常:

跨线程操作无效:控制'textBox1'从其创建的线程以外的线程访问.

winforms task-parallel-library

12
推荐指数
2
解决办法
9253
查看次数

c#任务多队列限制

我需要一个需要维护不同任务队列的环境,并且每个队列都有一个明确定义的可以为每个队列执行的并发线程数.像这样的东西:

  • 队列1 - > 3个线程;
  • 队列2 - > 6个线程;

任务系统的种类.我已经设法自己实现了这个使用普通的旧c#代码(又名System.Threading.Thread,lock和queue),它可以工作超过1年.但是,我一直在阅读有关TaskFactory和TaskScheduler奇迹的文章,关于.NET中内置类的可能性,但我没有找到证明这一点的例子.我想测试一下,并与我现在所做的比较,看看它是否工作得更好,如果有的话,更换它.

更多,我可以在不必限制/设置每个队列的并行线程数的情况下生存,只要我能够得到那个guarantee,即使队列#1在满负荷执行时imediatly执行队列#2的目标.

所以,我的问题是 - 是否有.net 4及更多内容,有人能指出我的样本吗?我整整一周都在寻找一个并没有得到相关的东西.

c# queue task task-parallel-library

12
推荐指数
1
解决办法
4065
查看次数

使用TaskCompletionSource的TaskCreationOptions的目的是什么?

对于我的内心运作方式,我有些不清楚TaskCompletionSource<>.

当Task<>使用the 创建一个简单的时候Factory,我希望这个任务在一个线程池中排队,除非我指定TaskCreationOptions.LongRunning,它将在一个新的线程中运行.

我的理解TaskCompletionSource是,我负责在任务结束或失败时触发,并且我完全控制如何管理线程.然而,ctor TaskCompletionSource允许我指定一个TaskCreationOptions,这让我感到困惑,因为我期望Scheduler无法处理任务本身.

TaskCreationOptions在一个上下文中的目的是TaskCompletionSource<>什么?

这是一个使用示例:

public Task<WebResponse> Download(string url)
{
    TaskCompletionSource<WebResponse> tcs = 
    new TaskCompletionSource<WebResponse>(TaskCreationOptions.LongRunning);

    var client = (HttpWebRequest)HttpWebRequest.Create(url);
    var async = client.BeginGetResponse(o =>
      {
          try
          {
              WebResponse resp = client.EndGetResponse(o);
              tcs.SetResult(resp);
          }
          catch (Exception ex)
          {
              tcs.SetException(ex);
          }
      }, null);


    return tcs.Task;
}
Run Code Online (Sandbox Code Playgroud)

c# task-parallel-library taskcompletionsource

12
推荐指数
1
解决办法
961
查看次数

即使在Asp.Net流中使用ConfigureAwait(false)后死锁也是如此

即使使用后我也遇到死锁ConfigureAwait(false),下面是示例代码.

根据示例http://blog.stephencleary.com/2012/02/async-and-await.html(#Avoding Context),这不应该是死锁.

这是我的班级:

public class ProjectsRetriever
{
    public string GetProjects()
    {
        ...
        var projects = this.GetProjects(uri).Result;
        ...
        ...
    }

    private async Task<IEnumerable<Project>> GetProjects(Uri uri)
    {
        return await this.projectSystem.GetProjects(uri, Constants.UserName).ConfigureAwait(false);
    }
}
Run Code Online (Sandbox Code Playgroud)

该类来自共享库:

public class ProjectSystem
{
    public async Task<IEnumerable<Project>> GetProjects(Uri uri, string userName)
    {
        var projectClient = this.GetHttpClient<ProjectHttpClient>(uri);
        var projects = await projectClient.GetProjects();
        // code here is never hit
        ...
}
Run Code Online (Sandbox Code Playgroud)

如果我在共享库中添加ConfigureAwait(false)以等待调用,则会起作用,其中进行HttpClient调用:

public class ProjectSystem
{
    public async Task<IEnumerable<Project>> GetProjects(Uri uri, string userName)
    {
        var …
Run Code Online (Sandbox Code Playgroud)

c# asp.net deadlock task-parallel-library async-await

12
推荐指数
2
解决办法
7082
查看次数

库中的Task.Yield()需要ConfigureWait(false)

它建议使用一个ConfigureAwait(false)当你可以随时,特别是在图书馆,因为它可以帮助避免死锁和提高性能.

我编写了一个大量使用异步的库(访问数据库的Web服务).图书馆的用户遇到了僵局,经过多次痛苦的调试和修补后,我将其追踪到了单独使用await Task.Yield().我使用过的其他任何地方.ConfigureAwait(false),但是不支持Task.Yield().

对于需要等效的情况,推荐的解决方案是Task.Yield().ConfigureAwait(false)什么?

我已经读过有关如何SwitchTo移除某个方法的内容.我可以看出为什么那可能是危险的,但为什么没有相应的Task.Yield().ConfigureAwait(false)?

编辑:

为了提供我的问题的进一步背景,这里有一些代码.我正在实现一个开源库,用于访问支持异步的DynamoDB(作为AWS的服务的分布式数据库).IX-Async库IAsyncEnumerable<T>提供了许多操作返回.该库不提供从以"块"提供行的数据源生成异步枚举的好方法,即每个异步请求返回许多项.所以我有自己的通用类型.该库支持预读选项,允许用户指定在调用实际需要之前应该请求多少数据.MoveNext()

基本上,这是如何工作的,我通过调用GetMore()和传递这些块之间的状态来请求块.我将这些任务放入chunks队列并将它们出列并将它们转换为我放在单独队列中的实际结果.这个NextChunk()方法就是问题所在.根据值的不同,ReadAhead我会在完成最后一个(最多)之后保持获取下一个块,直到需要一个值但不可用(无)或仅获取超出当前使用值的下一个块(一些).因此,获取下一个块应该并行/不阻止获取下一个值.枚举器代码是:

private class ChunkedAsyncEnumerator<TState, TResult> : IAsyncEnumerator<TResult>
{
    private readonly ChunkedAsyncEnumerable<TState, TResult> enumerable;
    private readonly ConcurrentQueue<Task<TState>> chunks = new ConcurrentQueue<Task<TState>>();
    private readonly Queue<TResult> results = new Queue<TResult>();
    private CancellationTokenSource cts = new CancellationTokenSource();
    private TState lastState;
    private TResult current;
    private …
Run Code Online (Sandbox Code Playgroud)

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

12
推荐指数
2
解决办法
1920
查看次数

将循环转换为任务

我有以下同步代码:

foreach ( var step in result ) {
  step.Run();
}
Run Code Online (Sandbox Code Playgroud)

我试图将其转换为任务,但我没有这样做.我尝试使用Task.WhenAll这样的方式转换它(我确实将async附加到方法签名):

var tasks = new List<Task>();
foreach ( var step in result ) {
    tasks.Add( new Task( () => step.Run() ) );
}
await Task.WhenAll( tasks );
Run Code Online (Sandbox Code Playgroud)

这会立即返回,不会执行该Run()方法.然后我尝试将其转换为以下代码:

var tasks = new List<Task>();
foreach ( var step in result ) {
    tasks.Add( new Task( () => step.Run() ) );
}
var task = Task.WhenAll( tasks );
task.Wait();
Run Code Online (Sandbox Code Playgroud)

这永远阻止.但是,当我在循环中创建它时,它可以工作:

foreach ( var step in result ) …
Run Code Online (Sandbox Code Playgroud)

c# asynchronous task-parallel-library async-await c#-5.0

12
推荐指数
3
解决办法
2420
查看次数

何时应该使用TaskScheduler.Current作为参数调用Task.ContinueWith?

我们正在使用StackOverflow中的此代码片段来生成一个任务,该任务在第一个任务集合成功完成后立即完成.由于其执行的非线性特性,async/await实际上并不可行,因此此代码使用ContinueWith().它没有指定的TaskScheduler,虽然,这一个号码 的 来源都提到可能是危险的,因为它使用TaskScheduler.Current时,大多数开发人员通常希望TaskScheduler.Default从延续的行为.

流行的智慧似乎是你应该总是将一个显式的TaskScheduler传递给ContinueWith.但是,我还没有看到关于何时最合适的TaskScheduler的明确解释.

什么是最好TaskScheduler.Current进入的情况的具体例子ContinueWith(),而不是TaskScheduler.Default?做出这个决定时是否有遵循的经验法则?

对于上下文,这是我所指的代码片段:

public static Task<T> FirstSuccessfulTask<T>(IEnumerable<Task<T>> tasks)
{
    var taskList = tasks.ToList();
    var tcs = new TaskCompletionSource<T>();
    int remainingTasks = taskList.Count;
    foreach(var task in taskList)
    {
        task.ContinueWith(t =>
            if(task.Status == TaskStatus.RanToCompletion)
                tcs.TrySetResult(t.Result));
            else
                if(Interlocked.Decrement(ref remainingTasks) == 0)
                    tcs.SetException(new AggregateException(
                        tasks.SelectMany(t => t.Exception.InnerExceptions));
    }
    return tcs.Task;
}
Run Code Online (Sandbox Code Playgroud)

c# multithreading task-parallel-library

12
推荐指数
2
解决办法
677
查看次数