请求新计算时取消异步CPU计算的实现方案

问题场景 #

应用在UI值变更时需执行大量CPU密集型任务，为避免UI卡顿，通过控件onchange事件调用async方法后台处理。初始实现能保持UI响应，但快速修改值会导致Result需数秒才稳定到最终结果。尝试用CancellationToken取消旧任务未成功，且核心处理方法Process是外部DLL方法，无法修改以支持取消令牌轮询。

初始实现代码 #

namespace Example
{
    public class Foo
    {
        public double Result { get; set; } = 0;
        public async Task UpdateAsync(double value)
        {
            await Task.Run(() => Process(value));
        }
        private double Process(double value)
        {
            // 模拟CPU密集型任务
            Thread.Sleep(1000);
            return value * 2;
        }
    }
}

失败的取消尝试代码 #

namespace Example
{
    public class Foo
    {
        public double Result { get; set; } = 0;
        private List<(Task task, CancellationTokenSource cts)> Tasks = new();
        public async Task UpdateAsync(double value)
        {
            Tasks.ForEach(v => v.cts.Cancel());
            CancellationTokenSource tokenSource = new CancellationTokenSource();
            Task task = Task.Run(() => Process(value), tokenSource.Token);
            Tasks.Add((task, tokenSource));
            await Task.WhenAll(Tasks.Select(t => t.task));
        }
        private double Process(double value)
        {
            // 模拟CPU密集型任务
            Thread.Sleep(1000);
            return value;
        }
    }
}

关键限制 #

实际场景中Process为外部DLL方法，无法修改以支持CancellationToken：

[DllImport("bar.dll")]
public static extern double Process(double value);

解决方案 #

因为外部DLL的Process无法响应取消令牌，我们无法终止正在运行的旧任务，但可以通过忽略旧任务结果、只应用最新请求结果的方式，让UI快速稳定到最终值，同时尽可能减少无效工作。

方案1：仅保留最新任务的结果 #

思路是给每个请求分配唯一ID，任务完成后仅当自身ID是最新ID时，才更新Result。旧任务即使继续运行，结果也会被丢弃，不会干扰UI。

namespace Example
{
    public class Foo
    {
        public double Result { get; set; } = 0;
        // 用volatile保证多线程下的可见性
        private volatile int _latestRequestId = 0;

        public async Task UpdateAsync(double value)
        {
            // 原子递增生成当前请求ID
            int currentRequestId = Interlocked.Increment(ref _latestRequestId);
            // 后台执行CPU密集型任务
            double result = await Task.Run(() => Process(value));
            // 仅当前请求是最新的，才更新结果
            if (currentRequestId == _latestRequestId)
            {
                Result = result;
                // 若实现了INotifyPropertyChanged，这里触发PropertyChanged事件更新UI
            }
        }

        [DllImport("bar.dll")]
        public static extern double Process(double value);
    }
}

方案2：限制并发+跳过过时请求 #

如果想进一步减少无效CPU占用，可以用信号量限制同时仅运行一个任务，在执行Process前检查当前请求是否已过时，过时则直接跳过执行。

namespace Example
{
    public class Foo
    {
        public double Result { get; set; } = 0;
        private volatile int _latestRequestId = 0;
        // 限制同时仅一个任务执行
        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

        public async Task UpdateAsync(double value)
        {
            int currentRequestId = Interlocked.Increment(ref _latestRequestId);
            try
            {
                await _semaphore.WaitAsync();
                // 检查当前请求是否已过时，过时则直接返回
                if (currentRequestId != _latestRequestId)
                    return;
                // 执行任务
                double result = Process(value);
                // 仅最新请求才更新结果
                if (currentRequestId == _latestRequestId)
                {
                    Result = result;
                }
            }
            finally
            {
                _semaphore.Release();
            }
        }

        [DllImport("bar.dll")]
        public static extern double Process(double value);
    }
}

方案对比 #

• 方案1：优点是响应最快，新请求无需等待旧任务；缺点是旧任务仍会占用CPU完成。
• 方案2：优点是减少无效的Process调用；缺点是新请求可能需要等待旧任务释放信号量，响应速度略慢。可根据实际场景选择。

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