1
// C++ 用多线程实现并发
2
std::thread t1(taskA);
3
std::thread t2(taskB);
4
t1.join();
5
t2.join();
6
// 需要互斥锁、条件变量等同步原语，容易出死锁

1
┌─────────────────────────────────────────────┐
2
│              Dart 事件循环                    │
3
│                                             │
4
│  1. 执行同步代码（main 函数体等）              │
5
│  2. 检查微任务队列（microtask queue）          │
6
│     └─ scheduleMicrotask / Future.then 内部  │
7
│  3. 检查事件队列（event queue）               │
8
│     └─ Timer / I/O 回调 / UI 事件            │
9
│  4. 回到第 2 步，无限循环                     │
10
│                                             │
11
└─────────────────────────────────────────────┘

1
// 发起网络请求不会阻塞
2
var future = httpClient.get(url);   // ← 立刻返回一个 Future，不等待
3
doOtherWork();                       // ← 可以继续做其他事
4
var response = await future;         // ← 需要结果时才等待

1
Future<T>
2
├── 未完成（pending）——操作还在进行中
3
├── 成功完成（completed with value）——得到了 T 类型的结果
4
└── 失败完成（completed with error）──—操作出错了

1
// 方式 1：async/await（推荐）
2
var result = await fetchData();
3
print(result);
4

5
// 方式 2：.then / .catchError（回调风格，不推荐）
6
fetchData()
7
  .then((result) => print(result))
8
  .catchError((e) => print('失败: $e'));

1
// async 标记函数为异步函数
2
// 返回类型自动变成 Future<T>
3
Future<int> calculateSum() async {
4
  var a = await fetchA();  // 暂停，等待 fetchA 完成
5
  var b = await fetchB();  // 暂停，等待 fetchB 完成
6
  return a + b;            // 最终结果包装在 Future<int> 里返回
7
}

1
Future<void> demo() async {
2
  print('1. before await');
3
  await Future.delayed(Duration(seconds: 1));
4
  print('2. after await');  // 1 秒后才执行
5

6
  // await 只暂停"这个函数"，不暂停整个应用
7
  // 在等待期间，UI 仍然可以响应用户操作
8
}

1
// ❌ 串行等待：总时间 = A + B + C（慢！）
2
var a = await fetchA();  // 等 A 完
3
var b = await fetchB();  // 再等 B 完
4
var c = await fetchC();  // 再等 C 完
5

6
// ✅ 并行等待：总时间 = max(A, B, C)（快！）
7
var results = await Future.wait([
8
  fetchA(),
9
  fetchB(),
10
  fetchC(),
11
]);
12
var a = results[0];
13
var b = results[1];
14
var c = results[2];

1
import 'dart:async';
2

3
// 3 秒后执行
4
Timer(Duration(seconds: 3), () {
5
  print('3 秒到了');
6
});
7

8
// 取消定时器
9
var timer = Timer(Duration(seconds: 10), () => print('不会执行'));
10
timer.cancel();

1
// 每 20 秒执行一次
2
var periodic = Timer.periodic(Duration(seconds: 20), (timer) {
3
  print('第 ${timer.tick} 次执行');
4
  if (timer.tick >= 5) {
5
    timer.cancel();  // 第 5 次后取消
6
  }
7
});

1
Timer? _pingTimer;
2
Timer? _reconnectTimer;
3

4
void _startPing() {
5
  _pingTimer?.cancel();
6
  _pingTimer = Timer.periodic(_pingInterval, (_) {
7
    //                         ^^^^^^^^^^^^
8
    //                   每 20 秒发一次 Ping
9
    if (_status == WsStatus.connected) {
10
      _send({'type': 'PING'});
11
    }
12
  });
13
}

1
void _scheduleReconnect() {
2
  if (_disposed) return;
3
  _reconnectTimer?.cancel();
4
  _reconnectTimer = Timer(_reconnectDelay, () {
5
    //                     ^^^^^^^^^^^^^^^
6
    //                3 秒后重连
7
    if (!_disposed) connect();
8
  });
9
}

1
// 取消所有定时器——通常在 dispose 中调用
2
void disconnect() {
3
  _reconnectTimer?.cancel();   // ← 取消重连定时器
4
  _pingTimer?.cancel();        // ← 取消心跳定时器
5
  _sub?.cancel();              // ← 取消 Stream 订阅
6
  _channel?.sink.close();      // ← 关闭 WebSocket
7
  _channel = null;
8
}

1
// setServerUrl：修改地址后重连，不需要等重连完成
2
if (reconnectIfConnected && ...) {
3
  disconnect();
4
  unawaited(connect());   // ← 启动重连但不等待
5
}
6

7
// _handlePersonaList：收到人格列表后加载历史，不阻塞当前流程
8
if (_pendingInitialHistoryAfterPersonaList) {
9
  _pendingInitialHistoryAfterPersonaList = false;
10
  unawaited(loadInitialHistory());  // ← 后台加载，不阻塞 UI
11
}

1
void _log(String message, {LogLevel level = LogLevel.info}) {
2
  final entry = LogEntry(DateTime.now(), level, message);
3
  _logs.add(entry);
4
  unawaited(_appendLogLine(entry.toString()));  // ← 写日志不需要等
5
  notifyListeners();
6
}

1
Future<bool> _waitHostReady(Duration timeout) async {
2
  final stopwatch = Stopwatch()..start();
3
  while (stopwatch.elapsed < timeout) {
4
    if (await _isHostReachable()) {
5
      return true;                                      // 可达了，返回
6
    }
7
    await Future<void>.delayed(const Duration(milliseconds: 500));
8
    //                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
9
    //                   每 500ms 检查一次，不是疯狂循环
10
  }
11
  return false;  // 超时
12
}

1
try {
2
  return await completer.future.timeout(timeout);
3
  //                             ^^^^^^^^^^^^^^^^^
4
  //              如果 timeout 时间内没有 complete，抛 TimeoutException
5
} on TimeoutException {
6
  _pendingResponses.remove(msgId);        // ← 清理未完成的请求
7
  throw Exception('$type 请求超时');       // ← 转换为友好的错误
8
}

1
final ws = await WebSocket.connect(
2
  _ws.serverUrl,
3
).timeout(const Duration(milliseconds: 1200));
4
//       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
5
//       1.2 秒内连不上就算不可达

1
class Service {
2
  // ❌ 编译错误！构造函数不能 async
3
  // Service() async { await init(); }
4

5
  // ✅ 正确做法：构造函数中启动异步操作
6
  Service() {
7
    _init();  // 启动异步初始化（不 await）
8
  }
9

10
  Future<void> _init() async {
11
    // ... 异步初始化逻辑 ...
12
  }
13
}

1
// ❌ 不好的做法
2
void syncMethod() {
3
  asyncMethod();  // 忘了 await！异常不会被捕获
4
}
5

6
// ✅ 做法 1：方法改成 async
7
Future<void> nowAsync() async {
8
  await asyncMethod();
9
}
10

11
// ✅ 做法 2：显式标记 unawaited
12
void syncMethod() {
13
  unawaited(asyncMethod());  // 明确表示不等待
14
}

1
// 串行执行（每次等上一次完成）
2
for (var url in urls) {
3
  await fetch(url);  // 一个一个来，慢！
4
}
5

6
// 并行执行（同时开始，等全部完成）
7
await Future.wait(urls.map((url) => fetch(url)));  // 快！

1
// 即使函数体是同步的，标记 async 后返回值也是 Future<int>
2
Future<int> getValue() async {
3
  return 42;  // 被包装成 Future<int>
4
}
5

6
// 如果不需要 await，就不要标记 async
7
int getValueSync() {
8
  return 42;  // 直接返回 int
9
}