Асинхронное программирование на 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:
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-функции должен быть 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 выполняет один шаг преобразования, и цепочка понятна. |
| Один callback | then() | Более лаконично, чем 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.
Другие расширенияНикогда не игнорируйте асинхронные ошибки. Каждый вызов асинхронной функции должен иметь соответствующую обработку ошибок. Необработанные асинхронные ошибки выводят предупреждения в режиме разработки и могут быть молча проигнорированы в продакшн-средах, что приводит к ошибкам, которые трудно отследить.