异步支持

import 'dart:async'; // 导入异步库，用于scheduleMicrotask

void main() {
  print('1. main函数开始');

  // 立即执行的同步代码
  print('2. 同步任务执行');

  // 异步任务一：Future，会被放入事件队列
  Future(() => print('4. Future任务执行 (事件队列)'));

  // 异步任务二：Future.delayed，也会被放入事件队列 (延迟后)
  Future.delayed(Duration.zero, () => print('5. Future.delayed(Duration.zero)任务执行 (事件队列，但可能在4后)'));

  // 异步任务三：scheduleMicrotask，会被放入微任务队列
  scheduleMicrotask(() => print('3. Microtask任务执行 (微任务队列)'));

  print('6. main函数结束'); // main函数结束，主线程将空闲，事件循环开始工作
}

/*
预期输出 (理论上，实际情况可能因VM实现略有微小差异，但大体顺序不变):
1. main函数开始
2. 同步任务执行
6. main函数结束
3. Microtask任务执行 (微任务队列)
4. Future任务执行 (事件队列)
5. Future.delayed(Duration.zero)任务执行 (事件队列，但可能在4后)
*/

void blockingFunction() {
  print('开始耗时同步计算...');
  // 模拟一个非常耗时的同步操作
  var sum = 0;
  for (int i = 0; i < 1000000000; i++) {
    sum += i;
  }
  print('耗时同步计算完成, sum: $sum');
}

void main() {
  print('主线程开始');
  // 这将阻塞主线程，直到blockingFunction执行完毕
  blockingFunction();
  print('主线程结束'); // 只有blockingFunction完成后才会打印
}

import 'dart:async'; // 导入async库

// 模拟一个网络请求，返回一个Future<String>
Future<String> fetchUserData(String userId) {
  // 使用Future.delayed模拟网络延迟
  return Future.delayed(Duration(seconds: 2), () {
    if (userId == 'user123') {
      return 'User Data for $userId: Name: Alice, Age: 30';
    } else if (userId == 'errorUser') {
      throw Exception('用户不存在或网络错误'); // 模拟错误情况
    } else {
      return 'User Data for $userId: No special info.';
    }
  });
}

// 模拟一个依赖于用户数据的操作
Future<String> processUserData(String data) {
  return Future.delayed(Duration(seconds: 1), () {
    print('正在处理数据: ${data.substring(0, 15)}...');
    return 'Processed Data: ${data.toUpperCase()}';
  });
}

void main() {
  print('1. 程序开始执行...');

  // --- 示例 1: 成功的Future链式调用 ---
  print('\n--- 示例 1: 成功获取并处理数据 ---');
  fetchUserData('user123')
      .then((data) {
        print('2. 成功获取用户数据: $data');
        return processUserData(data); // 返回一个新的Future，继续链式调用
      })
      .then((processedData) {
        print('3. 成功处理用户数据: $processedData');
      })
      .catchError((error) {
        // 这个catchError不会被触发，因为前面的Future都成功了
        print('4. 错误捕获 (不应触发): $error');
      })
      .whenComplete(() {
        print('5. 示例1: 数据获取和处理操作完成 (无论是成功还是失败)');
      });

  // --- 示例 2: 带有错误的Future链式调用 ---
  print('\n--- 示例 2: 带有错误的数据获取 ---');
  fetchUserData('errorUser')
      .then((data) {
        print('6. 成功获取用户数据 (不应触发): $data');
        return processUserData(data);
      })
      .catchError((error) {
        print('7. 错误捕获: ${error.toString()}');
        // 返回一个新的Future，可以返回一个默认值或者继续抛出错误
        return 'Fallback Data: Error occurred.';
      })
      .then((result) {
        print('8. 错误处理后继续执行: $result');
      })
      .whenComplete(() {
        print('9. 示例2: 数据获取和处理操作完成 (无论是成功还是失败)');
      });

  // --- 示例 3: 没有catchError的错误处理 ---
  print('\n--- 示例 3: 没有捕获的错误 ---');
  fetchUserData('anotherErrorUser') // 假设这个id也会触发错误
      .then((data) {
        print('10. 成功获取数据 (不应触发): $data');
      })
      // 注意这里没有catchError
      .whenComplete(() {
        print('11. 示例3: 数据获取操作完成 (但错误未被显式捕获)');
      });
  // 如果没有catchError，且错误没有被后续的then处理，
  // 那么未处理的错误最终会被Dart的全局错误处理机制捕获，例如Future.zone
  // 在这里，它可能会打印一个"Uncaught Error"到控制台。

  print('\n12. main函数结束，异步操作仍在后台进行...');
}

1. 程序开始执行...

--- 示例 1: 成功获取并处理数据 ---

--- 示例 2: 带有错误的数据获取 ---

--- 示例 3: 没有捕获的错误 ---

12. main函数结束，异步操作仍在后台进行...
正在处理数据: User Data for user...
2. 成功获取用户数据: User Data for user123: Name: Alice, Age: 30
3. 成功处理用户数据: PROCESSED DATA: USER DATA FOR USER123: NAME: ALICE, AGE: 30
5. 示例1: 数据获取和处理操作完成 (无论是成功还是失败)
7. 错误捕获: Exception: 用户不存在或网络错误
9. 示例2: 数据获取和处理操作完成 (无论是成功还是失败)
8. 错误处理后继续执行: Fallback Data: Error occurred.
11. 示例3: 数据获取操作完成 (但错误未被显式捕获)
Unhandled exception:
Exception: 用户不存在或网络错误
#0 fetchUserData.<anonymous closure> (file:///Users/yourname/Documents/dart_project/lib/main.dart:18:13)
#1      _RootZone.runUnary (dart:async/zone.dart:1679:58)
#2      _FutureListener.handleValue (dart:async/future_impl.dart:140:18)
#3      Future._propagateToListeners.handleValueCallback (dart:async/future_impl.dart:738:45)
#4      Future._propagateToListeners (dart:async/future_impl.dart:767:32)
#5      Future._completeWithValue (dart:async/future_impl.dart:575:5)
#6      _AsyncAwaitCompleter.complete (dart:async/async_manager.dart:28:13)
#7      _AsyncAwaitCompleter.start.<anonymous closure> (dart:async/async_manager.dart:36:15)
#8      _rootHandleDelayed (dart:async/zone.dart:1367:13)
#9      _CustomTimer.call (dart:async/zone.dart:1212:15)
#10     Timer.new. (dart:async/timer.dart:53:23)
#11     _Timer._runTimers (dart:isolate-patch/timer_impl.dart:395:19)
#12     _Timer._handleMessage (dart:isolate-patch/timer_impl.dart:426:7)
#13     _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:190:12)

import 'dart:async';

// 模拟一个耗时操作，返回Future<String>
Future<String> downloadFile(String url) async {
  print('  开始下载: $url...');
  await Future.delayed(Duration(seconds: 3)); // 模拟网络延迟
  print('  下载完成: $url');
  return 'Content_of_file_from_$url';
}

// 模拟另一个耗时操作，返回Future<bool>
Future<bool> processData(String data) async {
  print('    开始处理数据...');
  await Future.delayed(Duration(seconds: 2)); // 模拟CPU密集型操作
  print('    数据处理完成。');
  return data.length > 10;
}

// 模拟一个可能失败的操作
Future<String> fetchConfig(String configName) async {
  print('    开始获取配置: $configName...');
  await Future.delayed(Duration(seconds: 1));
  if (configName == 'critical') {
    throw Exception('无法获取关键配置: $configName'); // 模拟错误
  }
  print('    获取配置成功: $configName');
  return 'ConfigValue for $configName';
}


// --- 使用 async/await 的函数 ---
Future<void> performTaskSequence() async {
  print('--- 开始 performTaskSequence ---');
  try {
    String fileContent = await downloadFile('http://example.com/data.txt');
    print('接收到文件内容: ${fileContent.substring(0, 15)}...');

    String config = await fetchConfig('default');
    print('接收到配置: $config');

    bool processResult = await processData(fileContent);
    print('数据处理结果: $processResult');

    // 可以在await之后直接使用结果，如同同步代码
    if (processResult) {
      print('任务成功完成!');
    } else {
      print('数据未通过处理验证。');
    }
  } catch (e) {
    print('! ! ! 任务中发生错误: $e');
  } finally {
    print('--- performTaskSequence 结束 (清理工作) ---');
  }
}

// --- 带有预期错误的 async/await 函数 ---
Future<void> performTaskWithError() async {
  print('\n--- 开始 performTaskWithError (模拟错误) ---');
  try {
    String fileContent = await downloadFile('http://example.com/another.txt');
    print('接收到文件内容: ${fileContent.substring(0, 15)}...');

    // 这里会抛出异常
    String criticalConfig = await fetchConfig('critical');
    print('接收到关键配置: $criticalConfig'); // 这行代码将不会被执行

    bool processResult = await processData(fileContent + criticalConfig);
    print('数据处理结果: $processResult');
  } catch (e) {
    // 错误会被这里的catch捕获
    print('! ! ! performTaskWithError 捕获到错误: $e');
  } finally {
    print('--- performTaskWithError 结束 (清理工作) ---');
  }
}


void main() {
  print('主函数开始');

  // 调用异步函数
  performTaskSequence();
  performTaskWithError();

  print('主函数结束 (异步任务仍在后台运行)');
}

/*
预期输出大致顺序 (具体时间点取决于 Future.delayed):

主函数开始
--- 开始 performTaskSequence ---
  开始下载: http://example.com/data.txt...

--- 开始 performTaskWithError (模拟错误) ---
  开始下载: http://example.com/another.txt...
主函数结束 (异步任务仍在后台运行)

// 3秒后 (downloadFile完成)
  下载完成: http://example.com/data.txt
接收到文件内容: Content_of_fil...
    开始获取配置: default...
  下载完成: http://example.com/another.txt
接收到文件内容: Content_of_fil...
    开始获取配置: critical...

// 1秒后 (fetchConfig完成)
    获取配置成功: default
接收到配置: ConfigValue for default
    开始处理数据...
    开始获取配置: critical... (这里会报错，但async/await函数会捕获)

// 2秒后 (processData完成，同时criticalConfig报错)
    数据处理完成。
数据处理结果: true
任务成功完成!
--- performTaskSequence 结束 (清理工作) ---

! ! ! performTaskWithError 捕获到错误: Exception: 无法获取关键配置: critical
--- performTaskWithError 结束 (清理工作) ---
*/

Future<void> doSomethingAsync() async {
  print('Async task started');
  await Future.delayed(Duration(seconds: 1));
  print('Async task finished');
}

void main() {
  print('Main started');
  doSomethingAsync(); // 忘记 await。doSomethingAsync会立即返回一个Future，但main函数不会等待它。
  print('Main finished'); // 这会先于 'Async task finished' 打印
}

import 'dart:async';

// 模拟一个会成功的异步操作
Future<String> successfulFuture() {
  return Future.delayed(Duration(milliseconds: 500), () => '数据成功获取');
}

// 模拟一个会失败的异步操作
Future<String> failingFuture() {
  return Future.delayed(Duration(seconds: 1), () => throw Exception('网络连接失败！'));
}

// 模拟一个会抛出特定错误的异步操作
Future<int> calculateValue(int a, int b) {
  return Future.delayed(Duration(milliseconds: 700), () {
    if (b == 0) {
      throw ArgumentError('除数不能为零');
    }
    return a ~/ b;
  });
}

// --- 示例 1: 使用 .then(onError: ) 和 .catchError() ---
void demonstrateThenAndCatchError() {
  print('\n--- 示例 1: .then(onError: ) 和 .catchError() ---');

  // 1.1 使用 then 的 onError 参数
  failingFuture().then(
    (value) => print('示例1.1 成功: $value (不应打印)'),
    onError: (error, stackTrace) { // stackTrace 参数是可选的
      print('示例1.1 then(onError): 捕获到错误 - ${error.runtimeType}: ${error}');
      // 如果 onError 返回一个值或一个非错误 Future，则链条变为成功
      return '从错误中恢复的默认值';
    },
  ).then((value) {
    print('示例1.1 then(onError)处理后继续: $value');
  }).whenComplete(() {
    print('示例1.1 whenComplete 执行');
  });

  // 1.2 使用 catchError (更推荐用于链式错误处理)
  successfulFuture().then((value) {
    print('示例1.2-1 成功获取: $value');
    // 故意在这里抛出错误，看 catchError 是否能捕获
    throw FormatException('数据格式不符！');
  }).catchError((error) {
    print('示例1.2-1 catchError: 捕获到错误 - ${error.runtimeType}: ${error}');
    return '格式错误后的默认值'; // 恢复，后续then会执行
  }).then((value) {
    print('示例1.2-1 catchError处理后继续: $value');
  }).whenComplete(() {
    print('示例1.2-1 whenComplete 执行');
  });


  failingFuture().then((value) {
    print('示例1.2-2 成功 (不应打印): $value');
  }).catchError((error, stackTrace) {
    print('示例1.2-2 catchError: 捕获到错误 - ${error.runtimeType}: ${error}');
    // 可以选择重新抛出错误，或不返回任何值（相当于返回 null）
    // throw error; // 如果需要将错误继续传递下去
  }).whenComplete(() {
    print('示例1.2-2 whenComplete 执行');
  });
}

// --- 示例 2: 使用 async/await 与 try-catch ---
Future<void> demonstrateAsyncAwaitTryCatch() async {
  print('\n--- 示例 2: async/await 与 try-catch ---');

  // 2.1 成功情况
  try {
    String result = await successfulFuture();
    print('示例2.1 await成功: $result');
  } catch (e) {
    print('示例2.1 await捕获到错误 (不应触发): $e');
  } finally {
    print('示例2.1 finally执行');
  }

  // 2.2 失败情况
  try {
    String result = await failingFuture(); // 这里会抛出异常
    print('示例2.2 await成功 (不应触发): $result');
  } catch (e, s) { // 捕获到 Exception
    print('示例2.2 await捕获到错误: ${e.runtimeType}: $e');
    // print('堆栈信息: $s'); // 可以打印堆栈信息
  } finally {
    print('示例2.2 finally执行');
  }

  // 2.3 捕获特定类型的错误 (on 关键字)
  try {
    int value = await calculateValue(10, 0); // 这里会抛出 ArgumentError
    print('示例2.3 await成功 (不应触发): $value');
  } on ArgumentError catch (e) {
    print('示例2.3 捕获到特定错误 (ArgumentError): $e');
  } catch (e) { // 捕获其他类型错误
    print('示例2.3 捕获到其他错误: $e');
  } finally {
    print('示例2.3 finally执行');
  }
}

void main() {
  // 设置全局错误处理 (仅作演示，实际应用可能使用runZonedGuarded)
  // 这是为了演示如果没有被捕获的Future错误会如何表现。
  // 在Flutter中，此种错误会被FlutterError.onError或Zone捕获
  // Future.microtask(() { // 使用microtask确保在所有main函数代码执行后
  //   Zone.current.handleUncaughtError = (Object error, StackTrace stack) {
  //     print('!!! 全局未捕获异步错误: $error');
  //     // print('Stack: $stack');
  //   };
  // });

  print('程序开始执行');
  demonstrateThenAndCatchError();
  // 注意，这里调用 performTaskWithError 可能会因为未处理的 Future 错误导致主线程报错
  // 如果你需要展示未捕获错误，可以注释掉 `demonstrateAsyncAwaitTryCatch` 内部的 `try-catch`
  // 并在 Zone.current.handleUncaughtError 里观察
  demonstrateAsyncAwaitTryCatch(); 
  print('主函数结束，异步操作正在进行...');

  // 示例 3: 未捕获的错误
  print('\n--- 示例 3: 未捕获的错误 ---');
  failingFuture().then((value) {
    print('示例3 成功 (不应打印): $value');
  }); // 这里没有 .catchError 或 .then(onError: )
  // 这个错误最终会成为一个未捕获的错误，导致程序在异步操作完成后崩溃或被Zone捕获。
  // 在 Dart VM 中，通常会打印一个 "Unhandled exception" 并退出。
}

import 'dart:async'; // 导入async库

// --- 示例 1: 使用 StreamController 创建一个单订阅流 ---
class DataGenerator {
  final _controller = StreamController<int>();

  // Getter 返回 Stream，以便外部可以监听
  Stream<int> get stream => _controller.stream;

  void startGenerating() {
    int count = 0;
    Timer.periodic(Duration(seconds: 1), (timer) {
      if (!_controller.isClosed) {
        count++;
        _controller.add(count); // 发送数据事件
        if (count == 5) {
          timer.cancel();
          _controller.addError('数据生成器意外停止！'); // 发送错误事件
          _controller.close(); // 关闭Stream，发送onDone事件
        }
      } else {
        timer.cancel(); // 如果Stream已经被关闭，也停止计时器
      }
    });
  }

  void dispose() {
    _controller.close(); // 清理资源
  }
}

// --- 示例 2: async* (异步生成器) 函数创建 Stream ---
Stream<String> countdown(int from) async* {
  for (int i = from; i >= 0; i--) {
    await Future.delayed(Duration(seconds: 1)); // 模拟异步操作
    if (i == 2) {
      throw Exception('倒计时过程中发生错误'); // 在 Stream 中抛出错误
    }
    yield '倒计时: $i'; // 发送数据事件
  }
  // 函数执行完毕，Stream 会自动关闭
}

// --- 示例 3: 广播流 ---
Stream<int> _broadcastStreamController;
Stream<int> get broadcastCounterStream {
  if (_broadcastStreamController == null) {
    _broadcastStreamController = StreamController<int>().stream.asBroadcastStream();
    int count = 0;
    Timer.periodic(Duration(seconds: 2), (timer) {
      if (!_broadcastStreamController.isClosed) {
        count++;
        // 只有在 StreamController 是 StreamController<T> 实例时才能使用 add
        // 对于 asBroadcastStream() 转换后的 Stream，需要获取原始的 StreamController
        // 这里只是为了演示，实际通常是 StreamController 本身就是广播型的。
        // 为了简化，我们假设直接用一个广播型的 StreamController。
        // 正确的广播流创建方式应该如下：
        final bcController = StreamController<int>.broadcast();
        Timer.periodic(Duration(seconds: 2), (timer) {
            bcController.add(count++);
        });
        _broadcastStreamController = bcController.stream; // 重新赋值
      } else {
        timer.cancel();
      }
    });
  }
  return _broadcastStreamController;
}


void main() async {
  print('程序开始执行');

  // --- 示例 1: 单订阅流的监听 ---
  print('\n--- 示例 1: DataGenerator 单订阅流 ---');
  final generator = DataGenerator();
  // 监听Stream
  StreamSubscription<int> subscription = generator.stream.listen(
    (data) => print('监听器A收到数据: $data'),
    onError: (error) => print('监听器A收到错误: $error'),
    onDone: () => print('监听器A完成'),
    cancelOnError: true, // 遇到错误时自动取消订阅
  );

  await Future.delayed(Duration(seconds: 3)); // 让数据生成一段时间
  subscription.pause(); // 暂停接收
  print('监听器A已暂停');
  await Future.delayed(Duration(seconds: 2));
  subscription.resume(); // 恢复接收
  print('监听器A已恢复');

  // 尝试再次监听同一个单订阅流 (会报错)
  // try {
  //   generator.stream.listen((data) => print('监听器B收到数据: $data'));
  // } catch(e) {
  //   print('尝试再次监听单订阅流失败: $e');
  // }

  await Future.delayed(Duration(seconds: 4)); // 等待 Stream 完成或错误

  // --- 示例 2: async* (异步生成器) 流 ---
  print('\n--- 示例 2: async* (异步生成器) 流 ---');
  await for (var event in countdown(4)) { // 使用 await for 循环消费 Stream
    print(event);
  }
  // await for 循环会自动处理 Stream 的完成和错误
  // 它会在 Stream 中遇到错误时抛出异常，因此需要 try-catch 包裹
  try {
     await for (var event in countdown(4)) { // 再次调用会创建一个新的 Stream
       print(event);
     }
  } catch(e) {
    print('async* 流中捕获到错误: $e');
  }


  // --- 示例 3: 广播流 ---
  print('\n--- 示例 3: 广播流 ---');
  // 创建一个广播StreamController
  final bcController = StreamController<String>.broadcast();
  int broadcastCount = 0;
  Timer.periodic(Duration(seconds: 1), (timer) {
    if (!bcController.isClosed) {
      broadcastCount++;
      bcController.add('广播事件 $broadcastCount');
      if (broadcastCount == 3) {
        bcController.addError('广播流错误!');
      }
      if (broadcastCount == 5) {
        timer.cancel();
        bcController.close();
      }
    } else {
      timer.cancel();
    }
  });


  // 多个监听者可以同时监听广播流
  bcController.stream.listen(
    (data) => print('广播监听器X收到: $data'),
    onError: (error) => print('广播监听器X收到错误: $error'),
    onDone: () => print('广播监听器X完成'),
  );

  bcController.stream.listen(
    (data) => print('广播监听器Y收到: --> $data <--'),
    onError: (error) => print('广播监听器Y收到错误: --> $error <--'),
    onDone: () => print('广播监听器Y完成'),
  );

  await Future.delayed(Duration(seconds: 7)); // 确保所有异步操作有时间执行


  print('\n程序结束');
  generator.dispose(); // 清理资源
  bcController.close(); // 清理资源
}

import 'dart:async';
import 'dart:isolate'; // 导入Isolate库
import 'dart:math';

// --- 辅助函数：模拟耗时操作 ---
Future<String> _fetchData(String name, int duration, {bool fail = false}) async {
  print('    开始获取数据 ($name), 预计等待 ${duration}ms...');
  await Future.delayed(Duration(milliseconds: duration));
  if (fail && Random().nextBool()) { // 随机失败
    throw Exception('从 $name 获取数据失败！');
  }
  print('    结束获取数据 ($name)');
  return '$name_Data';
}

// --- 示例 1: Future 组合 ---
Future<void> demonstrateFutureComposition() async {
  print('\n--- 示例 1: Future 组合 ---');

  // Future.wait 示例
  print('  -- demonstrateFuture.wait --');
  try {
    List<String> results = await Future.wait([
      _fetchData('SourceA', 2000),
      _fetchData('SourceB', 1000),
      _fetchData('SourceC', 1500),
    ]);
    print('  所有数据获取成功: $results'); // ['SourceA_Data', 'SourceB_Data', 'SourceC_Data']
  } catch (e) {
    print('  Future.wait 捕获到错误: $e'); // 如果有任何一个 Future 失败
  }

  // Future.any 示例
  print('  -- demonstrateFuture.any --');
  try {
    String firstResult = await Future.any([
      _fetchData('FastAPI', 800),
      _fetchData('SlowAPI', 3000),
      _fetchData('FailureAPI', 500, fail: true), // 可能更快失败
    ]);
    print('  第一个完成的数据是: $firstResult');
  } catch (e) {
    print('  Future.any 捕获到错误 (第一个完成的是错误): $e');
  }
}

// --- 示例 2: Completer 的使用 ---
class Authenticator {
  final _loginCompleter = Completer<String>();

  // 暴露一个Future给外部等待
  Future<String> get onLoginCompleted => _loginCompleter.future;

  // 模拟登录过程，在某个时间点完成Future
  void login(String username, String password) async {
    print('  尝试登录: $username...');
    await Future.delayed(Duration(seconds: 2));

    if (username == 'admin' && password == 'password') {
      _loginCompleter.complete('登录成功！欢迎 $username'); // 成功完成
    } else {
      _loginCompleter.completeError(Exception('用户名或密码错误！')); // 失败完成
    }
  }
}

Future<void> demonstrateCompleter() async {
  print('\n--- 示例 2: Completer 的使用 ---');
  final authenticator = Authenticator();

  // 在异步函数中 await 等待登录结果
  authenticator.onLoginCompleted.then((message) {
    print('  监听登录成功: $message');
  }).catchError((error) {
    print('  监听登录失败: $error');
  });

  // 模拟在另一个地方触发登录
  await Future.delayed(Duration(milliseconds: 500));
  authenticator.login('guest', '123'); // 这次会失败

  await Future.delayed(Duration(seconds: 3)); // 等待上一个完成

  // 注意：Completer无法再次complete，会抛出StateError
  // authenticator._loginCompleter.complete('第二次尝试');
}


// --- 示例 3: Zone 全局错误处理 ---
void someBuggyAsyncCode() async {
  await Future.delayed(Duration(milliseconds: 100));
  throw Exception("这是 Zones 内部的一个未捕获的异步错误！");
}

void demonstrateZones() {
  print('\n--- 示例 3: Zone 全局错误处理 ---');
  // runZonedGuarded 捕获在这个 Zone 内所有未被 try-catch 捕获的异步错误
  runZonedGuarded(() async {
    print('  在 runZonedGuarded 内部执行异步代码...');
    await Future.delayed(Duration(milliseconds: 50));
    someBuggyAsyncCode(); // 这里会抛出未捕获的异步错误
    print('  如果错误被捕获，这句可能不会立即打印。');
  }, (error, stack) {
    print('  Zone 捕获到未处理的错误: $error');
    // 在生产环境中，你会在这里上报错误日志
    // print('  堆栈追踪: $stack');
  });

  print('  main 线程继续执行，Zone 内部错误已被捕获。');
}

// --- 示例 4: Isolates (计算密集型任务) ---
// Isolate 入口函数（必须是顶层函数或静态方法）
void expensiveComputation(SendPort sendPort) {
  print('    Isolate 1: 开始计算...');
  int sum = 0;
  for (int i = 0; i < 1000000000; i++) { // 模拟大量计算
    sum += i;
  }
  print('    Isolate 1: 计算完成，结果 $sum');
  sendPort.send(sum); // 将结果发送回主 Isolate
}

void demonstrateIsolates() async {
  print('\n--- 示例 4: Isolates ---');
  print('  主 Isolate: 启动昂贵计算...');

  // 1. 创建接收端口
  ReceivePort receivePort = ReceivePort();

  // 2. 启动新的 Isolate，并传入发送端口
  // Isolate.spawn 返回一个 Future<Isolate>
  // 该 Future 在新 Isolate 启动后完成
  Isolate isolate = await Isolate.spawn(
    expensiveComputation,
    receivePort.sendPort,
  );

  // 3. 监听接收端口，等待 Isolate 返回结果
  receivePort.listen((message) {
    print('  主 Isolate: 收到 Isolate 发送的结果: $message');
    isolate.kill(priority: Isolate.immediate); // 接收到消息后，杀死 Isolate
    receivePort.close();
  });

  print('  主 Isolate: 可以继续执行其他任务，不会阻塞 UI。');
  // 模拟主 Isolate 上的其他操作
  await Future.delayed(Duration(milliseconds: 100));
  print('  主 Isolate: 继续做一些轻量级工作...');
}


void main() async {
  print('程序开始');

  await demonstrateFutureComposition();
  await demonstrateCompleter();
  demonstrateZones(); // Zones 内部有 await，所以这里不需要 await
  await demonstrateIsolates(); // Isolates 内部有 await，所以这里需要 await

  print('\n所有异步演示结束。');
}