Key Concepts

This chapter covers the ideas that make Dart feel like Dart: asynchronous code with Future, async/await and Stream; isolates; mixins and extension methods; and how they show up in Flutter.

The event loop and Future

Dart code runs in a single-threaded event loop inside an isolate. Slow operations such as file or network access do not block; they return a Future, a promise of a later value. Inside an async function, await lets you write code in order while the event loop handles other work.

Future<String> fetchUser(int id) async {
  await Future.delayed(const Duration(milliseconds: 300)); // simulated network
  return 'user$id';
}

Future<void> main() async {
  print('start');
  final user = await fetchUser(1);
  print(user);

  // Start several operations at once and wait for all of them
  final users = await Future.wait([fetchUser(2), fetchUser(3)]);
  print(users); // [user2, user3]

  // Apply a time limit
  try {
    await fetchUser(4).timeout(const Duration(milliseconds: 100));
  } catch (e) {
    print('timed out: $e');
  }
}

An async function always returns a Future (Future<void> if there is no value). A dropped Future can swallow errors; when you deliberately skip await, mark it with unawaited() from dart:async.

Stream: many values over time

A Stream is a sequence of values arriving over time, such as file chunks, WebSocket messages or input events. An async* function emits values with yield; consume them with await for or listen.

Stream<int> countdown(int from) async* {
  for (var i = from; i > 0; i--) {
    await Future.delayed(const Duration(milliseconds: 200));
    yield i;
  }
}

Future<void> main() async {
  await for (final n in countdown(3)) {
    print(n); // 3, 2, 1
  }

  final evensSquared = countdown(6)
      .where((n) => n.isEven)
      .map((n) => n * n);
  final subscription = evensSquared.listen(
    (value) => print('value: $value'),
    onError: (Object e) => print('error: $e'),
    onDone: () => print('done'),
  );
  await subscription.asFuture<void>();
}

There are single-subscription streams, which can be listened to only once, and broadcast streams, which many listeners can share. When you need to push events yourself, use a StreamController.

Isolates: concurrency without shared memory

async/await does not move CPU-heavy work to another core. Run expensive computations, such as parsing a huge JSON document, in an isolate. An isolate has its own memory and event loop and communicates only through messages, so there are no data races and no locks.