【问题标题】:Retrying async functions using a task -- what approach is more efficient?使用任务重试异步函数——哪种方法更有效?
【发布时间】:2014-03-28 23:49:32
【问题描述】:

我想知道总体而言,哪种方法在内存和资源使用方面更有效。

特别是方法#1,我很难想象任务对象将如何创建和线程如何启动?有人可以详细解释一下幕后发生的事情吗?

如果两者之间没有区别,我想使用#1(希望避免冒泡异步)。使用#2,我知道编译器将在下面生成一个状态机并产生返回。 OTOH,#1 在概念上似乎是递归的,但在传统意义上它会像一个堆栈帧在另一个等待另一个堆栈帧那样是递归的吗?

方法一:

internal static Task ExecuteAsyncWithRetry(Func<Task> methodToExecute, Func<bool> shouldRetry)
    {
        var tcs = new TaskCompletionSource<object>();

        try
        {
            return methodToExecute().ContinueWith<Task>((t) =>
            {
                if (t.IsFaulted || t.IsCanceled)
                {
                    if (shouldRetry())
                    {
                        return ExecuteAsyncWithRetry(methodToExecute, shouldRetry);
                    }
                    else
                    {
                        tcs.SetException(t.Exception);
                    }
                }
                else
                {
                    tcs.SetResult(null);

                }

                return tcs.Task;
            }, TaskContinuationOptions.ExecuteSynchronously).Unwrap();
        }
        catch(Exception ex)
        {
            tcs.SetException(ex);
        }

        return tcs.Task;
    }

方法#2(忽略两者在异常传播上的差异):

internal static async Task ExecuteWithRetry(Func<Task> methodToExecute, Func<bool> shouldRetry)
    {
        while (true)
        {
            try
            {
                await methodToExecute();
            }
            catch(Exception ex)
            {
                if(!shouldRetry())
                {
                    throw;
                }
            }
        }
    }

【问题讨论】:

  • 第二种方法更易于阅读和理解。我的经验法则:尽可能使用 async-await。在你的情况下,这是可能的。但是在第二种情况下,您缺少某种终止条件。如果一切顺利,methodToExecute() 将被一遍又一遍地执行。
  • 注意,await 会丢失错误信息,因为它会解开 AggregateException 的包装。这对于像这样的通用辅助方法是不可取的。它不涉及解释异常。
  • 谢谢,@usr,但是,你能澄清一下丢失错误信息部分吗? await 不应该表现得像 UnWrap() 并传播内部任务的错误/异常吗?
  • 默认等待者丢弃除第一个内部异常之外的所有异常。

标签: c# asynchronous task-parallel-library async-await


【解决方案1】:

除了不同的异常和取消传播之外,还有另一个主要区别。

在第一种情况下,由于TaskContinuationOptions.ExecuteSynchronously,您的延续在任务完成的同一线程上运行。

在第二种情况下,它将在原始同步上下文中运行(如果 methodToExecute 在具有同步上下文的线程上被调用)。

尽管第一种方法可能更有效,但也可能难以理解(尤其是当您或其他人在一年后重新使用它时)。

我会遵循KISS principle 并坚持第二个,但有一个修正:

await methodToExecute().ConfigureAwait(false);

更新以解决评论:

“OTOH,#1 在概念上似乎是递归的,但在 传统意义上的在一个堆栈帧中等待另一个?”

对于 #1,它是在同一个堆栈帧上递归发生,还是在不同堆栈帧上异步发生,完全取决于 methodToExecute 内部的内容。在大多数情况下,如果您在 methodToExecute 中使用一些自然异步的 API,则不会有传统的递归。例如,HttpClient.GetStringAsync completes on a random IOCP pool thread 和 Task.Delay 在随机工作池线程上完成。

但是,即使是异步 API 也可能在同一个线程上同步完成(例如 MemoryStream.ReadAsync 或 Task.Delay(0)),在这种情况下会出现递归。

或者,在methodToExecute 中使用TaskCompletionSource.SetResult 也可能触发同步延续。

如果你真的想避免任何递归的可能性,请通过Task.Run(或Task.Factory.StartNew/Task.Unwrap)调用methodToExecute。或者,更好的是,删除 TaskContinuationOptions.ExecuteSynchronously。

对于 #2,同样的场景也是可能的,即使初始线程上有同步上下文。

【讨论】:

  • 当然,感谢您的回答,我确实知道它们的不同之处。但是,为了我个人对概念的理解/巩固,我希望能得到超越这些细微差别的答案。尤其是#1,我想知道幕后发生了什么。
  • @Kakira,现在我确定我关注了。如果您自己编写了此代码,您可能应该了解它的工作原理。如果不是,具体是哪一部分不明白?仅供参考,related question。
  • 就像我说的(别担心,这是我的代码),我试图想象幕后发生的事情。我特别想理解我问题的这一部分:“OTOH,#1 在概念上似乎是递归的,但在传统意义上它会像一个堆栈帧在另一个等待另一个堆栈帧那样是递归的吗?”
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2013-10-20
  • 2013-08-02
  • 2012-10-01
  • 1970-01-01
  • 2019-08-20
  • 2018-04-08
  • 1970-01-01
相关资源
最近更新 更多