【问题标题】:How to run an async delegate on captured ExecutionContext如何在捕获的 ExecutionContext 上运行异步委托
【发布时间】:2019-08-14 19:58:44
【问题描述】:

正如 Stephen Toub 在this post 中解释的那样,当您向 ActionBlock 提交消息时,您可以在调用 ActionBlock.Post 之前执行 ExecutionContext.Capture,将包含消息和 ExecutionContext 的 DTO 传递到块中,然后在消息处理委托中传递使用 ExecutionContext.Run 在捕获的上下文上运行委托:

public sealed class ContextFlowProcessor<T> {
    private struct MessageState {
        internal ExecutionContext Context;
        internal T Value;
    }

    private readonly ITargetBlock<MessageState> m_block;

    public ContextFlowProcessor(Action<T> action) {
        m_block = new ActionBlock<MessageState>(ms =>
        {
            if (ms.Context != null)
                using (ms.Context) ExecutionContext.Run(ms.Context, s => action((T)s), ms.Value);
            else 
                action(ms.Value);
        });
    }

    public bool Post(T item) {
        var ec = ExecutionContext.Capture();
        var rv = m_block.Post(new MessageState { Context = ec, Value = item });
        if (!rv) ec.Dispose();
        return rv;
    }

    public void Done() { m_block.DeclinePermanently(); }

    public Task CompletionTask { get { return m_block.CompletionTask; } }

当消息处理程序内部的逻辑是同步的时,这很有效。但是如何在捕获的 ExecutionContext 上运行一段 async 逻辑?我需要这样的东西:

m_block = new ActionBlock<MessageState>(async ms =>
{
      // omitting the null context situation for brevity
      using (ms.Context)
      {
         await ExecutionContext.Run(ms.Context, async _ => { callSomethingAsync(ms.Value) });
      }
});

显然,这不会编译,因为 ExecutionContext.Run 不支持异步委托(而 ActionBlock 支持) - 那么我该怎么做呢?

【问题讨论】:

  • 提供的link 指的是TPL Dataflow 的预发布版本,它与当前的API 不兼容(例如方法DeclinePermanently,属性CompletionTask)。所以我提供的信息不准确。我的实验表明ExecutionContext 是默认捕获的,ContextFlowProcessor 的行为与简单的ActionBlock 相同。你有一个例子表明不同吗?
  • 不是,不是。我查看了当前的源代码,它仅在启动新任务时(隐式)捕获 ExecutionContext,这种情况发生在您发布第一条消息或长时间间隔后的第一条消息时,但不适用于排队到正在运行的任务的后续消息-循环。
  • 正如here 解释的那样,async/await 关键字在幕后使用ExecutionContext。async/await 只是一些有助于在异步编程中模拟同步语义的基础设施。因此,当您使用ExecutionContext 时,这意味着您将手动处理事情。我认为ExecutionContext.Run 支持async/await 没有意义,而他们自己基于ExecutionContext.Run 并且他们正在使用它
  • 使用Task.Run怎么样?

标签: async-await tpl-dataflow executioncontext


【解决方案1】:

如果您可以提供一个独立的示例,以便我们尝试重现该问题,我们或许可以提供更好的答案。也就是说,可以使用简单的自定义同步上下文手动控制ExecutionContext(或者更确切地说,它的副本)跨await 延续的流。这是一个示例(警告 - 几乎未经测试!):

// using EcFlowingSynchronizationContext:

m_block = new ActionBlock<MessageState>(async ms =>
{
      using (ms.Context)
      using (var sc = new EcFlowingSynchronizationContext(ms.Context))
      {
         await sc.Run(async _ => { await callSomethingAsync(ms.Value); });
      }
});

// EcFlowingSynchronizationContext: flow execution context manually 

public class EcFlowingSynchronizationContext : SynchronizationContext, IDisposable
{
    private readonly ExecutionContext _ec;
    private readonly TaskScheduler _taskScheduler;

    public EcFlowingSynchronizationContext(ExecutionContext sourceEc) 
    {
        TaskScheduler ts = null;
        ExecutionContext ec = null;

        ExecutionContext.Run(sourceEc, _ =>
        {
            var sc = SynchronizationContext.Current;
            SynchronizationContext.SetSynchronizationContext(this);
            try
            {
                ts = TaskScheduler.FromCurrentSynchronizationContext();
                // this will also capture SynchronizationContext.Current,
                // and it will be flown by subsequent ExecutionContext.Run
                ec = ExecutionContext.Capture();
            }
            finally
            {
                SynchronizationContext.SetSynchronizationContext(sc);
            }
        }, null);

        _ec = ec;
        _taskScheduler = ts;
    }

    private void Execute(SendOrPostCallback d, object state)
    {
        using (var ec = _ec.CreateCopy())
        {
            ExecutionContext.Run(ec, new ContextCallback(d), state);
        }
    }

    public Task Run(Func<Task> action, CancellationToken token = default(CancellationToken))
    {
        return Task.Factory.StartNew(action, token, TaskCreationOptions.None, _taskScheduler).Unwrap();
    }

    public Task<TResult> Run<TResult>(Func<Task<TResult>> action, CancellationToken token = default(CancellationToken))
    {
        return Task.Factory.StartNew(action, token, TaskCreationOptions.None, _taskScheduler).Unwrap();
    }

    public override void Post(SendOrPostCallback d, object state)
    {
        ThreadPool.UnsafeQueueUserWorkItem(s => Execute(d, s), state);
    }

    public override void Send(SendOrPostCallback d, object state)
    {
        Execute(d, state);
    }

    public override SynchronizationContext CreateCopy()
    {
        return this;
    }

    public void Dispose()
    {
        _ec.Dispose();
    }
}

注意,您应该只使用CallContext.LogicalSetData(或AsyncLocal&lt;T&gt;)存储不可变值。即,如果您需要存储在从被调用者到调用者的异步流程中可能发生更改的内容,并且能够跟踪调用者中的更改,请将其设为类的属性,然后存储该类的实例。确保该类也是线程安全的,因为最终您可以有许多原始执行上下文的并发分支。

更多详情,请参考Stephen Cleary的优秀Implicit Async Context ("AsyncLocal")和"Eliding Async and Await"。

【讨论】:

  • 所以基本上,Task.Run 有一些额外的细节?
  • @zvolkov,不,它根本不使用Task.Run。为了方便起见,我只是让EcFlowingSynchronizationContext.Run 看起来相似。
  • 我的意思是,您的 sc.Run 使用 Task.Factory.StartNew 来完成我所询问的部分(运行异步代码),它在目标 EC 上运行它的方式是通过获取来自我的目标 EC.Run 内部的任务调度程序 FromCurrentSynchronizationContext - 但我想知道我是否可以直接在我的目标 EC.Run 中使用 Task.Factory.StartNew,而不创建这个额外的类?
  • @zvolkov 如果你像这样打电话给Task.Factory.StartNew,你会提供什么TaskScheduler?如果你给它TaskScheduler.Default,你会得到默认的 EC 传播行为,这首先是你不满意的。与自定义同步上下文和自定义任务调度程序的整个处理是改变它的传播方式。这个实现真的如你所愿吗?还是我错过了什么?
  • 不,只是想了解基本原理。我需要对此进行测试。
猜你喜欢
  • 2022-01-25
  • 1970-01-01
  • 1970-01-01
  • 2017-06-23
  • 2021-02-10
  • 1970-01-01
  • 2010-11-27
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多