Как можно прервать асинхронную задачу?

Прерывание асинхронных задач в C#

Прерывание асинхронных операций в C# — сложная тема, поскольку стандартные асинхронные задачи (Task) не имеют встроенного механизма принудительной остановки. Вместо этого используется модель кооперативной отмены через CancellationToken. Рассмотрим основные подходы.

1. Кооперативная отмена через CancellationToken

Это основной и рекомендуемый способ. Работает по принципу запроса на отмену, а не принудительного прерывания.

Базовый пример:

using System.Threading.Tasks;
using System.Threading;

async Task DoWorkAsync(CancellationToken cancellationToken)
{
    for (int i =五项; i < 100; i++)
    {
        // Проверяем запрос на отмену
        cancellationToken.ThrowIfCancellationRequested();
        
        await Task.Delay(1000); // Имитация работы
        Console.WriteLine($"Iteration {i}");
    }
}

// Использование
var cts = new CancellationTokenSource();
var task = DoWorkAsync(cts.Token);

// Запрашиваем отмену через 3 секунды
await Task.Delay(3000);
cts.Cancel();

try
{
    await task;
}
catch (OperationCanceledException)
{
    Console.WriteLine("Task was cancelled.");
}

2. Обработка отмены с возможностью продолжения работы

Иногда нужно не просто бросить исключение, а аккуратно завершить работу:

async Task ProcessDataAsync(CancellationToken cancellationToken)
{
    while (!cancellationToken.IsCancellationRequested)
    {
        // Выполняем итерацию работы
        await Task.Delay(500, cancellationToken);
        
        // Сохраняем промежуточные результаты
        SaveCheckpoint();
    }
    
    // Финальная очистка ресурсов
    CleanupResources();
    Console.WriteLine("Task completed gracefully.");
}

3. Комбинирование нескольких CancellationToken

Можно создать связанный токен, который отменяется при срабатывании любого из источников:

var cts1 = new CancellationTokenSource();
var cts2 = new CancellationTokenSource();
var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, cts2.Token);

// Токен сработает при отмене cts1 ИЛИ cts2
await SomeAsyncOperation(linkedCts.Token);

4. Ограничение времени выполнения (Timeout)

CancellationTokenSource поддерживает таймауты:

// Автоматическая отмена через 5 секунд
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await LongRunningOperationAsync(cts.Token);

5. Сложные случаи и альтернативы

Когда кооперативная отмена невозможна:

1. Вызов внешних библиотек без поддержки CancellationToken
2. Блокирующие операции в стороннем коде
3. Критические секции, где нельзя прерваться

Возможные решения:

• Отмена на уровне потока: Thread.Abort() (устарел и опасен, не рекомендуется)
• Изоляция в отдельном процессе: запуск в отдельном процессе и его убийство
• Паттерн "Ядро-оболочка": обертка вокруг несоперативного кода с периодическими проверками

async Task WrapLegacyCodeAsync(CancellationToken cancellationToken)
{
    var task = Task.Run(() => LegacyBlockingMethod());
    
    // Создаем задачу-offset, которая сработает при отмене
    var cancellationTask = Task.Delay(Timeout.Infinite, cancellationToken);
    
    // Ждем первую завершившуюся задачу
    var completedTask = await Task.WhenAny(task, cancellationTask);
    
    if (completedTask == cancellationTask)
    {
        // Здесь можно попытаться остановить LegacyBlockingMethod
        // через другие механизмы (флаги, прерывание потока и т.д.)
        RequestLegacyMethodStop();
    }
    
    return await task;
}

6. Важные предостережения

1. Не используйте Task.Dispose() для отмены — он не предназначен для этого
2. Избегайте Thread.Abort() — вызывает ThreadAbortException, может оставить ресурсы в неконсистентном состоянии
3. Всегда освобождайте ресурсы в блоках finally или через using
4. Проектируйте методы с поддержкой CancellationToken с самого начала

7. Best Practices

• Всегда передавайте CancellationToken в асинхронные методы, если они поддерживают отмену
• Распространяйте токен вниз по цепочке вызовов
• Используйте ThrowIfCancellationRequested() для немедленной реакции
• Логируйте отмены для отладки
• Предоставляйте опциональные токены с значением по умолчанию CancellationToken.None

// Правильная сигнатура метода
public async Task ProcessAsync(
    string data, 
    CancellationToken cancellationToken = default)
{
    // Проверка в начале
    cancellationToken.ThrowIfCancellationRequested();
    
    // И в долгих циклах
    foreach (var item in collection)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await ProcessItemAsync(item, cancellationToken);
    }
}

Вывод: В C# асинхронные задачи прерываются через кооперативную модель отмены. Это обеспечивает безопасное освобождение ресурсов и предсказуемое поведение. При проектировании асинхронных API всегда учитывайте возможность отмены и предоставляйте соответствующие механизмы.