Асинхронное программирование на Dart

Асинхронное программирование — одна из важнейших возможностей в современной разработке приложений.

Будь то сетевые запросы, чтение и запись файлов или операции с базой данных, асинхронная обработка необходима, чтобы избежать блокировки главного потока.

В этой главе рассматривается концепция Future, синтаксис async/await и способы обработки асинхронных ошибок.


Зачем нужно асинхронное программирование

Сначала разберитесь в разнице между синхронным и асинхронным выполнением.

Синхронный код выполняется строка за строкой по порядку; следующая строка не начинается, пока не завершится предыдущая.

Если операция должна ждать (например, сетевой запрос), вся программа зависнет.

Пример

Сравните результаты выполнения синхронного и асинхронного кода:

// Имитация длительной операции
String fetchDataSync() {
  // Синхронный код: предположим, что здесь нужно подождать 2 секунды
  // В течение этих 2 секунд вся программа не может ничего делать
  sleep(Duration(seconds: 2));  // Блокирующее ожидание
  return 'Получение данных завершено';
}

// Асинхронная версия: не блокирует главный поток
Future<String> fetchDataAsync() async {
  // Асинхронное ожидание: в течение этих 2 секунд программа может продолжать выполнять другие задачи
  await Future.delayed(Duration(seconds: 2));
  return 'Получение данных завершено';
}

void main() async {
  print('Начинаем синхронное получение данных...');
  var syncResult = fetchDataSync();
  print('Синхронный результат: $syncResult');
  print('(Примечание: программа зависает во время синхронного выполнения)');

  print('\n'Начинаем асинхронное получение данных...');
  print('После запуска запроса программа продолжает выполнять другие задачи...');
  var asyncResult = await fetchDataAsync();
  print('Асинхронный результат: $asyncResult');
  print('(Примечание: программа не зависает во время асинхронного выполнения)');
}
Starting to fetch data synchronously...
Synchronous result: Data fetch complete
(Note: The program is stuck during synchronous execution)

Starting to fetch data asynchronously...
After sending the request, the program continues executing other tasks...
Asynchronous result: Data fetch complete
(The program is not stuck during asynchronous execution)

В Dart все операции ввода-вывода (файлы, сеть, база данных) должны использовать асинхронные методы. Синхронный ввод-вывод блокирует весь Isolate, что в приложениях Flutter приводит к подтормаживанию UI.


Понятие Future

FutureПредставляет значение, которое "завершится в какой-то момент в будущем".

Это как обещание: сейчас у меня нет значения, но в будущем я обязательно дам вам значение типа T (или ошибку).

Future имеет три состояния:

StateОписание
Не завершеноАсинхронная операция всё ещё выполняется
Завершено с даннымиОперация успешно завершилась, и Future содержит значение результата
Завершено, но с ошибками (Завершено с ошибкой)Операция завершается неудачно, и Future содержит информацию об ошибке.

Пример

Создание и использование Future:

void main() {
  print('Program start');

  // Создание Future
  Future<String> future = Future(() {
    // Эта функция выполнится в какой-то момент в будущем
    return 'EXAMPLE async result';
  });

  print('Future created, but not yet completed');

  // Регистрируем колбэк: выполняется, когда Future завершится
  future.then((result) {
    print('Received result: $result');
  });

  print('Program continues...');
}
程序开始
Future 已创建,但还没完成
程序继续执行...
收到结果: EXAMPLE 异步结果

Обратите внимание на порядок вывода: "программа продолжает выполняться" выводится первой, а "результат получен" — после.

Это показывает, что колбэки Future выполняются асинхронно и не блокируют последующий код.


синтаксис async / await

async и await — это основной синтаксис для обработки асинхронных операций в Dart.

async помечает функцию как асинхронную, а await ожидает завершения Future и получает его результат.

Пример

// Ключевое слово async помечает функцию как асинхронную функцию
// Возвращаемый тип async-функции должен быть Future<T>
Future<String> fetchUserName(int id) async {
  // await ожидает завершения Future и получает его значение
  // Во время ожидания текущая функция приостанавливает выполнение, но не блокирует другой код
  await Future.delayed(Duration(seconds: 1));
  return 'User$id';
}

Future<int> fetchUserAge(int id) async {
  await Future.delayed(Duration(milliseconds: 500));
  return 20 + id;
}

// Выполнить несколько асинхронных операций последовательно
Future<void> printUserInfo(int id) async {
  print('Начинаем получение информации о пользователе...');

  // Ждём по очереди: сначала получаем имя, затем возраст
  var name = await fetchUserName(id);
  print('Получено имя: $name');

  var age = await fetchUserAge(id);
  print('Получен возраст: $age');

  print('ПРИМЕР пользователь: $name, возраст: $age');
}

// Выполняем несколько асинхронных операций одновременно
Future<void> printUserInfoParallel(int id) async {
  print(Начинаем одновременное получение информации о пользователе...);

  // Запускаем два запроса одновременно, не дожидаясь друг друга
  var nameFuture = fetchUserName(id);
  var ageFuture = fetchUserAge(id);

  // Дождитесь завершения обоих запросов
  var results = await Future.wait([nameFuture, ageFuture]);
  var name = results[0] as String;
  var age = results[1] as int;

  print(ПРИМЕР пользователь (параллельно): $name, возраст: $age);
}

void main() async {
  // Последовательное выполнение (общее время ≈ 1s + 0.5s = 1.5s)
  await printUserInfo(1);

  print('---');

  // Параллельное выполнение (общее время ≈ max(1s, 0.5s) = 1s)
  await printUserInfoParallel(2);
}
开始获取用户信息...
获取到名称: 用户1
获取到年龄: 21
EXAMPLE 用户: 用户1, 年龄: 21
---
开始并发获取用户信息...
EXAMPLE 用户(并发): 用户2, 年龄: 22

Если несколько асинхронных операций не зависят друг от друга, следует использовать Future.wait, чтобы выполнять их параллельно, а не ожидать их одну за другой. Это может значительно повысить производительность — общее время равно самой медленной операции, а не сумме всех операций.

Основные правила async/await

ПравилаОписание
асинхронные функции возвращают FutureДаже если функция возвращает T, после использования async она автоматически оборачивается в Future<T>.
await можно использовать только внутри async-функций.Обычные функции не могут использовать await
await приостанавливает текущую функциюНо он не блокирует выполнение другого кода
await получает результат FutureЕсли в Future есть ошибка, await выбросит исключение.

цепочка вызовов then / catchError

Помимо async/await, Dart также поддерживает цепочки вызовов с использованием then() и catchError().

Это традиционная запись в стиле Promise.

Пример

// Функция для имитации сетевого запроса
Future<String> fetchData(String url) {
  return Future.delayed(Duration(seconds: 1), () {
    if (url.isEmpty) {
      throw Exception(URL не может быть пустым);
    }
    return Данные из $url;
  });
}

void main() {
  print(Начало запроса...);

  // цепочка вызовов then / catchError
  fetchData('https://example.com/api')
      .then((data) {
        // Запрос выполнен успешно
        print(Получены данные: $data);
        return Обработано: $data;  // Возвращаемое значение будет передано в следующий then
      })
      .then((processed) {
        // Обработать возвращаемое значение предыдущего then
        print(processed);
      })
      .catchError((error) {
        // Единообразно перехватывать любую ошибку в цепочке
        print(Ошибка запроса: $error);
      })
      .whenComplete(() {
        // Выполняется независимо от успеха или неудачи (аналогично finally)
        print(Запрос завершён (независимо от успеха или неудачи));
      });

  print(Запрос отправлен, программа продолжается...);
}
开始请求...
请求已发出,程序继续...
获取到数据: 来自 https://example.com/api 的数据
处理后的: 来自 https://example.com/api 的数据
请求结束(无论成功或失败)

Как выбрать между async/await и then/catchError?

СценарииРекомендуемый подходПричина
Линейный асинхронный потокasync/awaitКод так же понятен, как синхронный код
Несколько одновременных запросовasync/await + Future.waitЯсная семантика
Цепочка преобразований данныхthen()Каждый then выполняет один шаг преобразования, и цепочка понятна.
Один callbackthen()Более лаконично, чем async/await

В большинстве случаев рекомендуется использовать async/await, так как он обладает лучшей читабельностью. Но then() всё ещё ценен при простой цепочной обработке. Их можно смешивать, но это не рекомендуется — функция должна использовать либо async/await, либо then/catchError; смешивание делает код трудным для понимания.


Обработка асинхронных ошибок

В асинхронных операциях могут возникать ошибки, поэтому для их обработки нужно использовать try-catch.

async/await делает обработку ошибок такой же простой, как синхронный код.

Пример

// Симулировать сетевой запрос, который может завершиться неудачно
Future<String> fetchUserProfile(int userId) async {
  await Future.delayed(Duration(seconds: 1));

  if (userId <= 0) {
    throw Exception('Неверный ID пользователя: $userId');
  }

  if (userId == 404) {
    throw HttpException('Пользователь не существует');
  }

  return 'Профиль пользователя $userId';
}

// Пользовательское исключение
class HttpException implements Exception {
  final String message;
  HttpException(this.message);

  @override
  String toString() => 'HttpException: $message';
}

Future<void> loadUserProfile(int userId) async {
  print('Загрузка профиля пользователя $userId...');

  try {
    var profile = await fetchUserProfile(userId);
    print('Успешно загружено: $profile');
  } on HttpException catch (e) {
    // Перехват конкретных асинхронных ошибок по типу
    print('Ошибка HTTP: $e');
    print('Подскажите пользователю: пожалуйста, проверьте, существует ли пользователь');
  } on Exception catch (e) {
    // Перехват других исключений
    print('Общая ошибка: $e');
  } finally {
    print('Операция загрузки завершена');
  }
}

void main() async {
  await loadUserProfile(1);    // Успех
  print('---');
  await loadUserProfile(404);  // HttpException
  print('---');
  await loadUserProfile(-1);   // Общее исключение
}
正在加载用户 1 的资料...
加载成功: 用户 1 的个人资料
加载操作结束
---
正在加载用户 404 的资料...
HTTP 错误: HttpException: 用户不存在
提示用户:请检查用户是否存在
加载操作结束
---
正在加载用户 -1 的资料...
一般错误: Exception: 无效的用户 ID: -1
加载操作结束

Правила обработки ошибок в асинхронных функциях:

  • Если в асинхронной функции выбрасывается исключение, оно автоматически оборачивается в Future.
  • Вызывающая сторона может использовать try-catch, чтобы перехватить исключение из await.
  • Если используется then(), исключения передаются в catchError().
  • Необработанные асинхронные исключения не приводят к падению программы, но это рассматривается как необработанная ошибка Future.

Никогда не игнорируйте асинхронные ошибки. Каждый вызов асинхронной функции должен иметь соответствующую обработку ошибок. Необработанные асинхронные ошибки выводят предупреждения в режиме разработки и могут быть молча проигнорированы в продакшн-средах, что приводит к ошибкам, которые трудно отследить.

Другие расширения