Polly同步线程中CancellationToken超时失效问题排查求助

需求与问题 #

核心需求 #

• 使用TimeoutStrategy.Optimistic超时策略
• 按指定clientTimeOut实现调用超时
• 通过CancellationToken实现线程超时
• 必须使用同步调用（异步调用会丢失HTTP请求头信息）

问题现象 #

添加CancellationToken后超时仍未生效，同步代码复用原线程，疑惑是否必须使用异步ExecuteAsync()或新线程。TimeoutStrategy.Pessimist可正常工作，但不符合同步调用要求。

原代码示例 #

public TResult ExecuteWrapper<TResult>(Func<CancellationToken ,TResult> func)
{
    int attempts = 0;
    int retryCounter = 3;
    int waitTime = 1000;
    int clientTimeOut = 10000;
    var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(10000));
    var cancellationToken = cts.Token;

    RetryPolicy retryPolicy = Policy.Handle<Exception>().Retry(retryCounter);
    retryPolicy = Policy.Handle<Exception>().WaitAndRetry(retryCounter, sleepDurationProvider: attempt => TimeSpan.FromMilliseconds(this.waitTime), onRetry: (exception, timeSpan) =>
    {
          logRetryException(timeSpan, attempts++, exception);
    });
    
    PolicyWrap retrypolicywrap = retryPolicy.Wrap(Policy.Timeout(TimeSpan.FromMilliseconds(clientTimeOut), TimeoutStrategy.Optimistic));
    return retrypolicywrap.Execute(func, cancellationToken);
} 

public void BaseFunction(){
   var result = ExecuteWrapper(() => DummyFunctionToSleepTheThread())
}

public string DummyFunctionToSleepTheThread(){
   //Reading http header from the request context
   //which will lost if we use async call 
   //Hence we can't use Task.Delay(milliseconds) here.
    int milliseconds = 15000;
    System.Threading.Thread.Sleep(milliseconds);
    return "SUCCESS";
}

失效原因分析 #

1. 乐观超时的协作本质：TimeoutStrategy.Optimistic是协作式超时，不会强制中断线程，完全依赖业务代码主动检查并响应CancellationToken。原代码中业务函数既未接收令牌，也未做任何检查，导致Polly的超时信号无法生效。
2. 参数传递错误：ExecuteWrapper定义的func是Func<CancellationToken, TResult>，但BaseFunction调用时传入的是无参lambda，令牌根本没传递到业务函数。
3. Thread.Sleep不支持取消：Thread.Sleep会阻塞线程且忽略所有取消信号，无法响应Polly触发的超时令牌。

解决方案 #

修复步骤 #

1. 传递CancellationToken到业务函数：修正BaseFunction的调用逻辑，将令牌传入目标函数。
2. 替换Thread.Sleep为支持取消的等待：使用CancellationToken.WaitHandle.WaitOne实现可取消的同步等待。
3. 调整PolicyWrap顺序：让重试策略包裹超时策略，确保每次重试都应用独立的超时限制。
4. 移除冗余CancellationTokenSource：Polly的乐观超时策略会自动管理超时令牌，无需额外创建重复的超时令牌。

修改后完整代码 #

public TResult ExecuteWrapper<TResult>(Func<CancellationToken, TResult> func)
{
    int attempts = 0;
    int retryCounter = 3;
    int waitTime = 1000;
    int clientTimeOut = 10000;

    // 定义重试策略：可捕获取消异常并重试
    var retryPolicy = Policy.Handle<OperationCanceledException>()
        .Or<Exception>()
        .WaitAndRetry(retryCounter, 
            attempt => TimeSpan.FromMilliseconds(waitTime), 
            (exception, timeSpan) => logRetryException(timeSpan, attempts++, exception));

    // 定义乐观超时策略
    var timeoutPolicy = Policy.Timeout(TimeSpan.FromMilliseconds(clientTimeOut), TimeoutStrategy.Optimistic);

    // 重试包裹超时：每次重试都执行独立的超时检查
    var policyWrap = retryPolicy.Wrap(timeoutPolicy);

    // 执行时由Polly自动注入超时令牌
    return policyWrap.Execute(func);
}

public void BaseFunction()
{
    // 传递CancellationToken参数给业务函数
    var result = ExecuteWrapper(token => DummyFunctionToSleepTheThread(token));
}

public string DummyFunctionToSleepTheThread(CancellationToken cancellationToken)
{
    // 保留读取HTTP请求头的逻辑（同步上下文不会丢失）
    int milliseconds = 15000;

    // 等待指定时间，同时监听取消令牌
    bool wasCanceled = cancellationToken.WaitHandle.WaitOne(milliseconds);
    if (wasCanceled)
    {
        // 抛出取消异常，触发Polly重试逻辑
        cancellationToken.ThrowIfCancellationRequested();
    }

    return "SUCCESS";
}

关键说明 #

• 同步调用的上下文保持：修改后的代码全程使用同步调用，不会脱离原请求上下文，HTTP头信息不会丢失，符合你的要求。
• 乐观超时的协作要求：所有耗时的同步操作都需要主动检查CancellationToken，否则超时策略无法生效。如果业务中有其他IO操作，也要使用支持取消的同步API。
• 重试逻辑的精准控制：可以通过Handle<OperationCanceledException>指定只重试因超时导致的取消异常，避免重试其他业务级取消场景。

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