Flutter中如何在异步方法启动后取消其执行？

你需要实现一个支持随时取消的多步骤异步方法，希望通过类似methodWithAlotOfSteps.cancel()的方式终止执行，但CancelableCompleter只能标记Future为取消状态，函数内部代码仍会继续运行，且不想在每一步都手动检查取消标志。以下是两种更优的实现方案：

方案一：用Isolate实现真正的任务终止 #

Dart的单线程Event Loop无法中断正在执行的同步代码或已发起的异步操作，CancelableCompleter本质只是管理Future的完成状态，无法真正停止任务逻辑。而Isolate是独立的执行线程，直接杀死Isolate就能立刻终止所有内部代码的运行，这是最可靠的取消方式。

代码实现 #

首先封装一个可取消的任务类：

class CancelableTask {
  Isolate? _isolate;
  final Completer<void> _completer = Completer<void>();

  Future<void> run(Future<void> Function() task) async {
    final receivePort = ReceivePort();
    
    // 将任务放到独立Isolate中执行
    _isolate = await Isolate.spawn((SendPort sendPort) async {
      try {
        await task();
        sendPort.send('completed');
      } catch (e) {
        sendPort.send('error:$e');
      } finally {
        Isolate.exit();
      }
    }, receivePort.sendPort);

    // 监听Isolate的执行结果
    receivePort.listen((message) {
      if (message == 'completed') {
        _completer.complete();
      } else if (message.startsWith('error:')) {
        _completer.completeError(message.substring(6));
      }
      receivePort.close();
    });

    return _completer.future;
  }

  // 取消任务：直接杀死Isolate
  void cancel() {
    _isolate?.kill(priority: Isolate.immediate);
    _isolate = null;
    if (!_completer.isCompleted) {
      _completer.completeError('Task canceled');
    }
  }
}

然后改造你的业务方法：

CancelableTask? _currentLongTask;

// 启动多步骤任务
Future<void> startLongRunningTask() async {
  _currentLongTask = CancelableTask();
  try {
    await _currentLongTask!.run(() async {
      callMethodA();
      await callMethodB();
      // ... 其他所有步骤
    });
  } catch (e) {
    if (e == 'Task canceled') {
      print('任务已取消');
    } else {
      print('任务执行失败: $e');
    }
  } finally {
    _currentLongTask = null;
  }
}

// 点击取消按钮时调用
void cancelCurrentTask() {
  _currentLongTask?.cancel();
}

方案二：Stream分步控制（仅适合异步步骤场景） #

如果你的任务由多个异步步骤组成（没有长时间的同步计算），可以把步骤包装成Stream，通过takeWhile判断是否继续执行：

class StepCancelableTask {
  bool _canceled = false;

  Future<void> execute() async {
    // 将所有步骤转为Stream
    await Stream.fromIterable([
      () => callMethodA(),
      () async => await callMethodB(),
      // ... 其他步骤
    ]).takeWhile((_) => !_canceled) // 未取消才继续执行
      .forEach((step) async {
        await step();
      });

    if (_canceled) throw 'Task canceled';
  }

  void cancel() => _canceled = true;
}

注意：这个方案只能在异步步骤的间隙终止任务，如果某一步是耗时的同步计算（比如大循环），还是无法中断，此时优先选择Isolate方案。

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