Future

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void futureStateDemo() async {
  print('=== Future的状态和缓存 ===');
  
  // 创建一个Future
  var future = Future.delayed(Duration(seconds: 2), () {
    print('Future计算完成');
    return 42;  // 计算结果
  });
  
  // 状态1: Uncompleted（未完成） - 0~2秒
  print('创建后立即检查:');
  print('  是否完成? ${future is Future<int>}'); // true，但还未计算
  print('  当前时间: ${DateTime.now()}');
  
  // 等3秒，让Future完成
  await Future.delayed(Duration(seconds: 3));
  
  // 状态2: Completed with value（已完成，有值） - 2秒后
  print('\n3秒后检查:');
  var value = await future;  // ⭐ 这里是从缓存取值！
  print('  取值: $value');
  print('  再次取值: ${await future}');  // 再次从缓存取
  
  // 状态3: Completed with error（已完成，有错误）
  var errorFuture = Future.error(Exception('测试错误'));
  try {
    await errorFuture;
  } catch (e) {
    print('\n错误Future: $e');
  }
  // 错误也被缓存！
  try {
    await errorFuture;  // 同样的错误
  } catch (e) {
    print('再次获取同样的错误: $e');
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void main() async {
  print('开始');
  
  // 并行启动所有Future
  var future1 = fetchData(1);  // 立即启动，不等待
  var future2 = fetchData(2);  // 立即启动，不等待  
  var future3 = fetchData(3);  // 立即启动，不等待
  
  var time = DateTime.now();

  // 等待所有Future完成
  var data1 = await future1;
  var data2 = await future2;
  var data3 = await future3;
  
  print('结果: $data1, $data2, $data3');
  print('总耗时: ${(DateTime.now()).difference(time).inSeconds}秒');
}

Future<String> fetchData(int index) {
  print('开始获取数据$index, 当前时间: ${DateTime.now()}');
  return Future.delayed(Duration(seconds: 10), () {
    // 模拟网络请求
    return '从服务器获取的数据$index';
    // 抛出异常模拟错误
    // throw Exception('网络错误');
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void main() async {
  print('1. main开始');
  
  // 这3个Future立即进入"微任务队列"
  var future1 = fetchData(1);
  var future2 = fetchData(2);
  var future3 = fetchData(3);
  
  print('2. Future已创建，但未等待');
  
  // 没有await，main函数继续执行
  print('3. main继续执行');
  
  // main函数结束，但程序不会立即退出
  // 因为还有未完成的Future
  print('4. main结束');
  
  // 注意：即使main函数结束，Future仍在后台执行
  // 但程序会等待所有未完成的Future吗？看下面的测试
}

Future<String> fetchData(int index) {
  print('开始获取数据$index');
  return Future.delayed(Duration(seconds: 2), () {
    print('数据$index完成');  // 这个还会执行吗？
    return '数据$index';
  });
}