调用TaskCompletionSource.Task.Wait()是否存在同步转异步问题？含异步续行选项

已知同步转异步（sync-over-async）是不良实践，但存在两个疑问：

• 调用TaskCompletionSource.Task.Wait()时是否会存在同步转异步问题？
• 若创建TaskCompletionSource时使用TaskCreationOptions.RunContinuationsAsynchronously选项，答案是否会改变？

补充说明 #

并非所有Task对象的使用场景都相同：Task在async/await出现前就已被引入，用于并行编程。例如以下代码未执行任何异步操作，不存在sync-over-async问题：

var task = Task.Run(() => Thread.Sleep(10_000));
task.Wait();

背景 #

Kafka客户端提供一个同步的消息发送方法Produce，该方法接受一个用于异步报告投递状态的委托：

void Produce(
      TopicPartition topicPartition,
      Message<TKey, TValue> message,
      Action<DeliveryReport<TKey, TValue>> deliveryHandler = null);

在部分场景中，需要等待投递报告返回后再继续执行，执行环境可能是同步或异步上下文。为此实现了如下类：

internal class DeliveryReportAwaiter<TKey, TValue> : IDisposable
{
    private const int WaitForDeliveryGracePeriodFactor = 2;
    private readonly int _waitDeliveryReportTimeoutMs;
    private readonly ILogger _logger;
    private readonly CancellationTokenSource _cancellationTokenSource;
    private readonly TaskCompletionSource _taskCompletionSource;

    private bool _disposed;

    public DeliveryReportAwaiter(int waitDeliveryReportTimeoutMs, ILogger logger)
    {
        _logger = logger;
        _waitDeliveryReportTimeoutMs = waitDeliveryReportTimeoutMs *
            WaitForDeliveryGracePeriodFactor;

        _taskCompletionSource = new TaskCompletionSource(
            TaskCreationOptions.RunContinuationsAsynchronously);
        _cancellationTokenSource = new CancellationTokenSource();
        // in case OnDeliveryReportReceived was never called
        _cancellationTokenSource.Token.Register(SetTaskTimeoutException);
    }

    public void WaitForDeliveryReport(CancellationToken token)
    {
        token.ThrowIfCancellationRequested();
        _cancellationTokenSource.CancelAfter(_waitDeliveryReportTimeoutMs);
        
        // Is this considered sync-over-async?
        _taskCompletionSource.Task.Wait(token);
    }

    public Task WaitForDeliveryReportAsync(CancellationToken token)
    {
        token.ThrowIfCancellationRequested();
        _cancellationTokenSource.CancelAfter(_waitDeliveryReportTimeoutMs);
        return _taskCompletionSource.Task.WaitAsync(token);
    }

    public void OnDeliveryReportReceived(DeliveryReport<TKey, TValue> deliveryReport,
        Action<DeliveryReport<TKey, TValue>> handleReportAction)
    {
        if (_disposed)
        {
            _logger.LogWarning(
                "The delivery report for the message {Key} on topic {Topic} arrived " +
                    "after the awaiter was disposed due to timeout or cancellation. " +
                    "The delivery status is {Status}",
                deliveryReport.Key,
                deliveryReport.Topic,
                deliveryReport.Status);

            return;
        }

        if (!_cancellationTokenSource.TryReset())
        {
            SetTaskTimeoutException();
        }
        else
        {
            handleReportAction?.Invoke(deliveryReport);
            _taskCompletionSource.TrySetResult();
        }
    }

    public void Dispose()
    {
        if (_disposed)
        {
            return;
        }

        _disposed = true;
        _cancellationTokenSource.Dispose();
    }

    private void SetTaskTimeoutException()
    {
        var errorMessage = $"Producer timed out while waiting for publish " +
            $"confirm for {_waitDeliveryReportTimeoutMs}ms!";
        _taskCompletionSource.TrySetException(new KafkaTimeoutException(errorMessage));
    }
}

回答 #

1. 调用TaskCompletionSource.Task.Wait()属于sync-over-async不良实践吗？ #

是的，这属于sync-over-async范畴。

sync-over-async的核心问题是在同步代码中阻塞线程，等待一个异步触发的操作完成，会导致线程资源浪费，在带同步上下文的环境（如UI线程、老版ASP.NET请求上下文）中还可能引发死锁风险。

在你的Kafka场景中，TaskCompletionSource的Task完成依赖于Kafka客户端异步触发的投递报告回调——这个回调本质是异步事件，你用Wait()阻塞当前线程等待它完成，完全符合sync-over-async的定义，是应该避免的不良实践。

2. 使用RunContinuationsAsynchronously选项是否会改变结论？ #

不会。

这个选项的作用仅在于：当调用TrySetResult/TrySetException完成Task时，确保Task的延续代码（比如await该Task后执行的逻辑）不会在调用TrySet*的线程上同步执行，而是异步排队到线程池或合适的上下文执行。它只影响Task完成后后续代码的执行方式，不会改变Wait()操作本身的阻塞性质——Wait()依然会同步占用当前线程，直到Task完成，因此依然属于sync-over-async不良实践。

针对你场景的优化建议 #

• 优先使用已实现的WaitForDeliveryReportAsync方法，在异步代码中用await等待，避免阻塞线程。
• 如果必须在同步环境中等待：
  • 尽量避免在带同步上下文的线程（如UI线程）中调用Wait()；若无法避免，需确保Kafka回调不会占用该上下文（你的场景中Kafka回调通常在线程池执行，因此不会引发死锁，但线程阻塞的问题依然存在）。
  • 长远来看，建议推进代码异步化，逐步替代同步阻塞的调用方式。

内容的提问来源于stack exchange，提问作者Artur