在我看来，你对aync/await的阅读太多了，它们只是一种更好的异步语法，这样你就不会以一堆嵌套的回调结束，它们不会改变对象是如何创建和重用的。
不过这很容易测试，试着运行以下代码：

Future<int> functionA()  {
  return Future.delayed(const Duration(seconds: 3), () => 1);
}

Future<int> functionB() async {
  return await Future.delayed(const Duration(seconds: 3), () => 1);
}

Future measureTime(Function() callback) async {
  final start = DateTime.now();
  await callback();
  final end = DateTime.now();
  print("Duration: ${end.difference(start)}");
}

Future main() async {
  await measureTime(functionA);
  await measureTime(functionA);
  await measureTime(functionB);
  await measureTime(functionB);
}

这导致：

Duration: 0:00:03.004000
Duration: 0:00:03.005000
Duration: 0:00:03.006000
Duration: 0:00:03.001000

参见this gist。
现在，谈谈发生了什么。

Future<int> functionA()  {
  return Future.delayed(const Duration(seconds: 3), () => 1);
}

在函数A中，你返回一个Future，它在延迟3秒后返回1，每次你调用函数A，它都会创建一个新的Future，每次你等待它完成都需要3秒。

Future<int> functionB() async {
  return await Future.delayed(const Duration(seconds: 3), () => 1);
}

在函数B中，你所做的实际上非常相似，你仍然在创建一个新的future，每次函数被调用时，它都要等待3秒才能返回，但是await只是意味着它要等到future完成，然后在从函数返回之前执行一个noop。
你可以把async/await看作是Futures之上的语法糖，所以如果你把它“解开”，函数B看起来就像这样：

Future<int> functionB() {
  return Future.delayed(const Duration(seconds: 3), () => 1)
    .then((result) => result);
}

当函数这么短的时候，没有太大的区别，但是如果我们看一看一个更长的函数，就可能更清楚为什么async/await是有用的。

Future<int> functionC() async {
  final firstPart = await Future.delayed(const Duration(seconds: 3), () => 1);
  final secondPart = await Future.delayed(const Duration(seconds: 1), () => firstPart + 1);
  return secondPart;
}

可以翻译成：

Future<int> functionC() {
  return Future.delayed(const Duration(seconds: 3), () => 1)
    .then((firstPart) {
      return Future.delayed(const Duration(seconds: 1, () => firstPart + 1);
    });
}

第二个函数要难读得多，而第一个函数可以像普通代码一样读，实际上你甚至可以这样写它，使它更易读：

Future<int> functionC() async {
  await Future.delayed(const Duration(seconds: 3);
  final firstPart = 1;
  await Future.delayed(const Duration(seconds: 1));
  return firstPart + 1;
}