飞镖中的未来/完成者行为没有异步运行

Question

我只是想了解 Futures 的行为。这是一个示例代码：

import'dart:async';

main() {

  Future short = shortWait();
  Future medium = mediumWait();
  Future long = longWait();
  long.then((String e)=>print(e));
  medium.then((String e)=> print(e));
  short.then((String e)=> print(e));
  }

  Future<String> longWait() {
  Completer c = new Completer<String>();
  for (int i=0; i<100000000; i++);   // creating long latency
  c.complete("long");
  return c.future;
  }
  Future<String> mediumWait() {
    Completer c = new Completer<String>();
    for (int i=0; i<10000; i++);    // creating medium length latency
    c.complete("medium");
    return c.future;
  }
  Future<String> shortWait() {
    Completer c = new Completer<String>();
    c.complete("short");    // no latency
    return c.future;
  }


// short  
// medium
// long

我注意到了一些事情。首先，代码似乎是同步的，而延迟最长的函数 longWait() 是阻塞的。直到所有内容都可用时才会显示输出，然后一次显示所有内容。我认为它应该首先显示任何可用的内容，然后在 Futures 完成时显示。

其次，显示顺序似乎反映了 Future short/medium/long = shortWait/mediumWait/longWait() 的显示顺序。即更改这些行的顺序，输出的顺序也会相应更改。每种方法的延迟时间有多长并不重要，也不会影响 short/medium/long.then((e) => print(e)) 的显示顺序。

我希望代码 1) 在数据可用时显示输出，以及 2) 输出顺序应该反映函数的延迟。除了理解 Futures 的基本概念之外，我实际上并没有尝试做任何事情。

Answer 1

请记住，Dart 中的 异步 并不意味着 并行。

您在示例中所做的实质是将五个任务放在一个队列中：

1. 数到100000000
2. 打印“长”
3. 数到10000
4. 打印“中等”
5. 打印“短”

所以他们按那个顺序执行。

在 Dart 中，异步意味着代码在等待某事发生时不必阻塞。这通常是核心库提供的功能，例如从文件中获取数据，或通过网络进行交互——由操作系统或浏览器执行的任务。

一种思考方式是，Dart 程序可以与操作系统或浏览器执行的操作“并行”执行，但不能与自身执行。

Dart 还可以在等待计时器触发的情况下“并行”执行代码。例如：

import 'dart:async';

main() {

   // Long latency
  (new Future.delayed(new Duration(seconds: 5)).then((_) => print('long')));

  // Medium latency
  (new Future.delayed(new Duration(seconds: 2)).then((_) => print('medium')));

  // Short latency
  (new Future.delayed(new Duration(seconds: 1)).then((_) => print('short')));

  print('go');
}

打印：

go
short
medium
long

Answer 2

Future<String> longWait() {
  Completer c = new Completer<String>();
  for (int i = 0; i < 100000000; i++); // creating long latency
  c.complete("long");
  return c.future;
}

这不是异步做事。只有在 for 循环完成后，您才会返回未来。这使得这个函数是同步的。

要使其异步，请尝试以下操作：

Future<String> longWait() {
  Completer c = new Completer<String>();

  new Future.delayed(new Duration(seconds: 4), () {
    c.complete('long');
  });

  return c.future;
}

Future<String> mediumWait() {
  Completer c = new Completer<String>();

  new Future.delayed(new Duration(seconds: 2), () {
    c.complete('medium');
  });

  return c.future;
}

Future<String> shortWait() {
  Completer c = new Completer<String>();

  new Future.delayed(new Duration(seconds: 0), () {
    c.complete('short');
  });

  return c.future;
}

理想情况下，您可以完全避免使用Completer，因为Future.delayed 返回一个未来。

Future<String> longWait() {
  return new Future.delayed(new Duration(seconds: 10), ()=>'long');
}
Future<String> mediumWait() {
  return new Future.delayed(new Duration(seconds: 5), ()=>'medium');
}
Future<String> shortWait() {
  return new Future.delayed(new Duration(seconds: 0), ()=>'short');
}