Asynchronous Programming #

A responsive Flutter app is one that never locks up the user interface (UI jank or freezing) while running heavy tasks like fetching data from an API, reading a local database, or processing large files. This success rests entirely on asynchronous programming. In the Dart ecosystem, this concept is implemented very elegantly through a single-threaded concurrency model driven by the Event Loop mechanism. We’ll break down in depth how Dart manages these non-blocking operations using fundamental instruments like Future, async/await, Stream, and how to design robust async architectures free from memory leaks.

Why Asynchronous Programming Is Vital #

Modern mobile and desktop apps are required to run at 60 frames per second (FPS), even up to 120 FPS on devices with modern screens. This means the UI Thread only has about 16.6 milliseconds (for 60 FPS) or 8.3 milliseconds (for 120 FPS) to finish layout calculations, element drawing, and user input processing in each frame.

If you run a long-running operation synchronously on the main thread, the entire user interface will stop responding for the duration of that operation. This event is commonly called UI Hang or Jank.

In traditional programming languages like Java, C#, or C++, this problem is generally solved by creating new threads running in parallel. However, conventional shared-memory multi-threading brings very high complexity:

  • Race Conditions: Two threads try to modify the same data simultaneously, causing app state corruption.
  • Deadlocks: Thread A waits for a lock held by Thread B, while Thread B waits for a lock held by Thread A, locking the app forever.
  • Resource Overhead: Each thread has a fairly large stack memory allocation overhead and burdens the operating system.

Dart takes a different approach. By default, Dart runs on a single-threaded execution model inside an isolated container called an Isolate. Because memory isn’t shared with other threads, you avoid race conditions and deadlocks. To handle long-duration tasks without blocking the main thread, Dart relies on a non-blocking async system led by the Event Loop.

Let’s compare the difference between synchronous execution (wrong) and asynchronous execution (correct):

// ANTI-PATTERN: Synchronous data call that blocks the UI Thread
String fetchUserSummarySync() {
  // Holds thread execution for a full 3 seconds synchronously
  // During these 3 seconds, the Flutter app will be COMPLETELY FROZEN!
  sleep(const Duration(seconds: 3));
  return 'VIP User';
}

void updateDashboardSync() {
  print('1. Starting dashboard sync...');
  final summary = fetchUserSummarySync(); 
  print('2. User data: $summary');
  print('3. Dashboard update complete.');
}

// ====================================================================

// CORRECT: Asynchronous data call (non-blocking)
Future<String> fetchUserSummaryAsync() {
  // Returns control to the main thread immediately
  // The wait operation is scheduled in the background
  return Future.delayed(const Duration(seconds: 3), () => 'VIP User');
}

void updateDashboardAsync() {
  print('1. Starting dashboard sync...');
  fetchUserSummaryAsync().then((summary) {
    print('2. User data: $summary');
  });
  print('3. Dashboard stays responsive while data is loading...');
}

Event Loop — The Heart of Dart Concurrency #

Every Isolate in Dart has one main execution thread and one Event Loop running continuously. The Event Loop is responsible for taking tasks that enter the execution queue and running them one by one on that main thread.

Structurally, the Event Loop manages two queues with very different priority levels:

  1. Microtask Queue (High Priority): This queue is used for very short internal Dart tasks that must be completed immediately before external tasks are processed.
  2. Event Queue (Normal Priority): This queue contains all external events like I/O (file or network access), responses from timers, user input (screen touches, keyboard presses), and UI drawing by Flutter.

The Event Loop’s working mechanism can be visualized through the following flow diagram:

flowchart TD
    Start["App Starts (Main)"] --> RunSync["Run Synchronous Code to Completion"]
    RunSync --> LoopStart{"Any Microtasks in Queue?"}
    LoopStart -- "Yes" --> ExecMicro["Run Frontmost Microtask"]
    ExecMicro --> LoopStart
    LoopStart -- "No" --> CheckEvent{"Any Events in Queue?"}
    CheckEvent -- "Yes" --> ExecEvent["Run Frontmost Event"]
    ExecEvent --> LoopStart
    CheckEvent -- "No" --> WaitEvent["Wait for New Events"]
    WaitEvent --> LoopStart

Priority Execution Rules #

The Event Loop will always exhaust all tasks in the Microtask Queue first before taking a single task from the Event Queue. Every time one event finishes executing, the Event Loop returns to thoroughly check the Microtask Queue before processing the next event.

Let’s prove this priority through the following code example:

import 'dart:async';

void main() {
  print('1 - Sync');

  // Scheduling a task on the Event Queue
  Future(() {
    print('2 - Event Queue (First)');
  });

  // Scheduling a task on the Microtask Queue
  Future.microtask(() {
    print('3 - Microtask Queue (First)');
  });

  // Scheduling a task on the Event Queue with a delay
  Future.delayed(const Duration(milliseconds: 50), () {
    print('4 - Event Queue (With Delay)');
  });

  // Alternative way to schedule a Microtask directly
  scheduleMicrotask(() {
    print('5 - Microtask Queue (Second)');
  });

  print('6 - Sync');
}

If you run the code above, the output order produced is as follows:

  1. 1 - Sync and 6 - Sync are printed first because they are synchronous instructions executed directly by the main thread.
  2. 3 - Microtask Queue (First) and 5 - Microtask Queue (Second) are printed next because the Microtask Queue is processed immediately after synchronous code finishes.
  3. 2 - Event Queue (First) is printed after the entire Microtask Queue is empty.
  4. 4 - Event Queue (With Delay) is printed last because it requires a 50-millisecond wait before entering the active queue.
Critical Warning: Never put mathematical calculations or heavy computation inside the Microtask Queue. Because the Microtask Queue refuses to give the Event Queue a chance to run until it’s empty, clogging the microtasks will immediately stop screen rendering and user input processing. Your app’s UI will freeze completely.

Future — Representing a Value That Comes Later #

Future<T> is a Dart object representing the final result of an asynchronous operation whose result value (of type T) isn’t available yet when the object is created. This object acts like a promise that data will be provided in the future.

The Three States of a Future #

Every Future object has a lifecycle divided into three main states:

flowchart TD
    Uncompleted["Uncompleted (Pending)"] -->|"Operation Succeeded"| CompletedValue["Completed with Value (Success)"]
    Uncompleted -->|"Operation Failed"| CompletedError["Completed with Error (Failure)"]
  1. Uncompleted (Pending): The async operation is running in the background. At this stage, you can’t read the result value or error message yet.
  2. Completed with Value (Success): The async operation finished successfully. The Future stores the result value of type T, ready for your app to use.
  3. Completed with Error (Failure): The async operation failed because an error (exception) occurred. The Future stores the error object that you must handle immediately.

Instant Future Constructors #

Besides wrapping built-in async operations (like HTTP clients or file reading), you can create Future instances manually using several built-in Dart constructors:

// 1. Future.value: Creates a Future that completes immediately with a success value
Future<int> successFuture = Future.value(200);

// 2. Future.error: Creates a Future that completes immediately with a failure
Future<void> failedFuture = Future.error(Exception('Connection Refused'));

// 3. Future.delayed: Creates a Future that completes after a certain delay
Future<String> delayedFuture = Future.delayed(
  const Duration(seconds: 2),
  () => 'Hello after 2 seconds',
);

// 4. Future.sync: Runs the function synchronously before returning the Future
Future<String> syncFuture = Future.sync(() {
  // This part executes synchronously immediately when the line is declared
  return 'Immediate Execution';
});

Callback API: then, catchError, and whenComplete #

Before Dart introduced the async/await syntax, developers consumed Future values using chaining API methods. Although this style is now being replaced, understanding it is very important because it’s the fundamental foundation of all Dart async operations:

import 'dart:math';

Future<double> generateRandomNumber() {
  return Future.delayed(const Duration(seconds: 1), () {
    if (Random().nextBool()) {
      return 99.9;
    } else {
      throw Exception('Failed to generate random number');
    }
  });
}

void executeTask() {
  print('Starting task...');
  
  generateRandomNumber()
      .then((value) {
        // Callback if the Future succeeds (Completed with Value)
        print('Success: The number obtained is $value');
      })
      .catchError((error) {
        // Callback if an error occurs (Completed with Error)
        print('An error occurred: $error');
      })
      .whenComplete(() {
        // Callback ALWAYS called at the end, like a 'finally' block
        print('Task finished processing.');
      });
      
  print('Task scheduled in the background...');
}

The Danger of Callback Hell (Anti-Pattern) #

The main weakness of the .then() calling style is when you have several asynchronous operations that depend on each other sequentially. Your code will indent extremely deep and become very hard to read:

// ANTI-PATTERN: Callback Hell making code unreadable
void loadUserData() {
  authenticateUser().then((token) {
    fetchProfile(token).then((profile) {
      getPreference(profile.id).then((preference) {
        applyTheme(preference.theme);
      }).catchError((e) => print('Failed to load preferences'));
    }).catchError((e) => print('Failed to load profile'));
  }).catchError((e) => print('Failed to authenticate'));
}

async and await — Writing Async with a Sync Feel #

To solve the complexity problem of .then() chains, Dart provides the async and await keywords. This syntax is syntactic sugar that lets you write async code with a flow structure exactly like conventional synchronous code.

Declaring async Functions #

Every function that wants to use the await keyword must be marked with the async keyword right after the function parameter declaration. A function marked with async will automatically wrap its return value in a Future object.

// Without the async keyword, you must return a Future manually
Future<String> getTitle() {
  return Future.value('Book Title');
}

// With the async keyword, a String return value is automatically wrapped into Future<String>
Future<String> getTitleAsync() async {
  return 'Book Title'; // Automatically wrapped into Future.value('Book Title')
}

Using await #

The await keyword is used in front of an async function call. This instruction tells Dart to suspend the current async function’s execution until the awaited Future object finishes processing and returns its value.

It’s important to understand that await does not block the app’s main execution thread. While the function’s execution is suspended, the thread is freed to process other events in the Event Queue, keeping the user interface responsive.

Let’s rewrite the previous Callback Hell using clean, readable async/await:

// CORRECT: Very clean sequential async flow using async/await
Future<void> loadUserData() async {
  try {
    final token = await authenticateUser();
    final profile = await fetchProfile(token);
    final preference = await getPreference(profile.id);
    applyTheme(preference.theme);
  } catch (error) {
    // All errors from any line above are caught centrally here
    print('Failed to process user data: $error');
  } finally {
    // The cleanup part that definitely executes
    hideLoadingSpinner();
  }
}

Specific Error Handling #

When using async/await, you can leverage Dart’s built-in error handling (try, on, catch, finally) to catch different error types in a structured way:

Future<void> uploadPhoto(String filePath) async {
  try {
    final bytes = await readFile(filePath);
    await sendBytesToServer(bytes);
  } on SocketException catch (e) {
    // Catching network errors specifically
    print('Network error: ${e.message}');
  } on FileSystemException catch (e) {
    // Catching file reading errors specifically
    print('File cannot be read: ${e.message}');
  } catch (e) {
    // Catching other unexpected errors
    print('An unknown error occurred: $e');
  } finally {
    cleanTemporaryFiles();
  }
}

Optimizing Async Performance with Parallelism #

One of the most common mistakes developers make when writing async code is running operations sequentially when those operations don’t depend on each other. This needlessly extends the app’s wait duration.

Consider the following app dashboard loading scenario:

// ANTI-PATTERN: Slow sequential execution (Total wait time: 3s + 2s = 5 seconds)
Future<void> loadDashboardSlow() async {
  final startTime = DateTime.now();

  // Takes 3 seconds
  final profile = await fetchUserProfileFromServer(); 
  
  // Takes 2 seconds
  final transactions = await fetchRecentTransactionsFromServer(); 

  updateDashboardUI(profile, transactions);
  
  final duration = DateTime.now().difference(startTime).inSeconds;
  print('Finished loading dashboard in $duration seconds.'); // Output: 5 seconds
}

Because fetching transactions doesn’t need data from the user profile, the two operations above should run simultaneously (in parallel) to save the user’s wait time.

Using Future.wait #

You can use the Future.wait function to run a group of Futures in parallel. This function returns one new Future object that completes after all the Futures inside it have successfully finished.

// CORRECT: Running Futures in parallel (Total wait time: max(3s, 2s) = 3 seconds)
Future<void> loadDashboardFast() async {
  final startTime = DateTime.now();

  // Starting both operations simultaneously without the await keyword on each line
  final Future<Profile> profileFuture = fetchUserProfileFromServer();
  final Future<List<Transaction>> transactionFuture = fetchRecentTransactionsFromServer();

  // Waiting for both to finish at the same time
  final List<dynamic> results = await Future.wait([
    profileFuture,
    transactionFuture,
  ]);

  // Extract results by array index
  final profile = results[0] as Profile;
  final transactions = results[1] as List<Transaction>;

  updateDashboardUI(profile, transactions);

  final duration = DateTime.now().difference(startTime).inSeconds;
  print('Finished loading dashboard in $duration seconds.'); // Output: 3 seconds
}

Using the wait Extension on Records (Dart 3) #

Since Dart version 3, you’re given a much cleaner, type-safe parallelism alternative using the Record feature:

// CORRECT: Using Tuple/Record.wait for type safety (Dart 3+)
Future<void> loadDashboardTypeSafe() async {
  // Using tuple syntax and record destructuring
  final (profile, transactions) = await (
    fetchUserProfileFromServer(),
    fetchRecentTransactionsFromServer()
  ).wait;

  // The profile variable is automatically of type 'Profile' and transactions is 'List<Transaction>'
  // No manual type casting needed using the 'as' keyword
  updateDashboardUI(profile, transactions);
}

Using Future.any and Future.timeout #

In situations where you want to optimize response time, Dart provides advanced functionality:

Future.any: Returns the value from the Future that completes fastest among the list of Futures passed in.

Future<String> fetchFastestServer() async {
  // Useful if you have several mirror servers and want to use the fastest
  return await Future.any([
    requestFromServer('https://server-asia.example.com'),
    requestFromServer('https://server-europe.example.com'),
    requestFromServer('https://server-us.example.com'),
  ]);
}

Future.timeout: Limits the execution duration of a Future so the app doesn’t wait forever if the server has issues.

Future<void> loadDataWithTimeout() async {
  try {
    final data = await fetchReportFromServer().timeout(
      const Duration(seconds: 5),
    );
    displayReport(data);
  } on TimeoutException catch (_) {
    // Caught if the server doesn't respond within 5 seconds
    showAlternativeLocalData();
    print('Connection lost because the time limit was exceeded.');
  }
}

Stream — A Continuous Data Flow #

If Future plays the role of representing a single value coming in the future, then Stream is an object representing a series of values arriving periodically over time.

The difference between these async data models can be illustrated as follows:

flowchart TD
    subgraph FutureModel["Future Model (Single Value)"]
        direction LR
        FStart["Start Request"] --> FPending["Pending Status"]
        FPending -->|"Returns Data"| FSuccess["One Single Value"]
    end
    subgraph StreamModel["Stream Model (Multiple Values)"]
        direction LR
        SStart["Start Subscription"] --> SListen["Listening Status"]
        SListen -. Data 1 .-> SEmit1["First Value"]
        SEmit1 -. Data 2 .-> SEmit2["Second Value"]
        SEmit2 -. Data 3 .-> SEmit3["Third Value"]
        SEmit3 -->|"Stream Done"| SDone["Done Status"]
    end

The simplest analogy:

  • Future is like ordering food online. You place an order, wait a while, the food is delivered once, and the transaction is complete.
  • Stream is like subscribing to video streaming. After you press play, data continuously flows to your device in stages until the video finishes or you close the app.

Creating a Stream Using async* #

The most common way to produce stream data is using a generator function. This function uses the async* marker (with an asterisk) and the yield keyword to send new values into the stream channel:

// A stream generator function emitting a countdown number every second
Stream<int> startCountdown(int startValue) async* {
  for (int i = startValue; i >= 0; i--) {
    await Future.delayed(const Duration(seconds: 1));
    yield i; // Emitting a value to the Stream object being listened to
  }
}

You can also create instant Stream objects using several built-in Dart functions:

// Creating a stream from an existing List of data
Stream<String> wordsStream = Stream.fromIterable(['Learn', 'Dart', 'Async']);

// Creating a periodic stream that sends an incrementing number every 2 seconds
Stream<int> timerStream = Stream.periodic(
  const Duration(seconds: 2),
  (count) => count,
);

Two Stream Categories: Single-Subscription vs Broadcast #

Dart classifies streams into two categories with very different usage characteristics:

1. Single-Subscription Stream #

By default, all streams in Dart only allow a maximum of one active listener during their lifecycle. If a second listener tries to subscribe to the same stream, Dart will throw a StateError.

  • Characteristics: Guarantees all data is delivered sequentially and no data is missed since the subscription started.
  • Use Cases: Local database reading, binary file transfer, long HTTP responses.
final Stream<int> mySingleStream = Stream.fromIterable([1, 2, 3]);

mySingleStream.listen((data) => print('Listener 1: $data'));

// DON'T: Listening a second time on a single-subscription stream
// mySingleStream.listen((data) => print('Listener 2: $data')); // ERROR: Bad state

2. Broadcast Stream #

Broadcast Streams are designed to be listened to by many listeners simultaneously.

  • Characteristics: Values are emitted in real time. If a new listener joins midway, it will only receive new values emitted after its subscription time started (it won’t receive old values).
  • Use Cases: GPS sensor systems, screen touch interactions, WebSocket integration, global app state distribution.
// Converting a single-subscription stream into a broadcast stream
final Stream<int> broadcastStream = Stream.fromIterable([1, 2, 3]).asBroadcastStream();

broadcastStream.listen((data) => print('Listener A: $data'));
broadcastStream.listen((data) => print('Listener B: $data')); // VALID

Consuming a Stream #

There are two main methods most often used to consume data from a stream channel:

1. Using the await for Loop #

This method is ideal inside functions marked with async. The loop reads incoming data one by one and automatically stops when the stream channel closes.

Future<void> printStreamResults() async {
  final countdownStream = startCountdown(5);

  print('Starting monitoring...');
  await for (final value in countdownStream) {
    // Waiting 1 second in each loop iteration non-blocking
    print('Current value: $value');
  }
  print('Stream channel closed.');
}

2. Using the listen() Method #

The .listen() method is more flexible because it lets you register error handling functions and completion functions explicitly:

void monitorSensor() {
  final Stream<int> sensorStream = getSensorData();

  final StreamSubscription<int> subscription = sensorStream.listen(
    (data) {
      print('Sensor reading: $data');
    },
    onError: (error) {
      print('Sensor error occurred: $error');
    },
    onDone: () {
      print('Sensor disabled.');
    },
    cancelOnError: false, // Don't cancel the subscription even if an error occurs once
  );
}

Mastering StreamController and StreamTransformer #

To implement complex async data delivery architectures, you need a more flexible control tool than just the async* generator function.

StreamController #

StreamController acts as a full control bridge. This object separates the data entry point using the sink property and the data exit point using the stream property.

flowchart LR
    Producer["Data Producer"] -->|"Input (sink.add)"| Sink["StreamController.sink"]
    Sink -. Processing .-> Stream["StreamController.stream"]
    Stream -->|"Output (listen)"| Consumer["Data Consumer"]

Let’s look at a StreamController implementation in a real scenario:

import 'dart:async';

class ChatService {
  // Creating a controller to distribute incoming messages
  final _messageController = StreamController<String>.broadcast();

  // Data Entry Point: Used by the message producer
  StreamSink<String> get messageSink => _messageController.sink;

  // Data Exit Point: Used by the UI to listen for messages
  Stream<String> get messageStream => _messageController.stream;

  void sendMessage(String message) {
    if (message.trim().isNotEmpty) {
      messageSink.add(message); // Sending data to the stream
    }
  }

  // Must be cleaned up when the service is destroyed
  void dispose() {
    _messageController.close(); // Closing the stream channel
  }
}

StreamTransformer #

StreamTransformer is used to perform manipulation, filtering, or data transformation comprehensively before the data is sent to the final consumer:

import 'dart:async';

// Creating a custom transformer to censor profanity
final profanityTransformer = StreamTransformer<String, String>.fromHandlers(
  handleData: (data, sink) {
    // Changing profane words into star censors
    final cleanData = data.replaceAll('profane', '*****');
    sink.add(cleanData); // Sending clean data to the output stream
  },
  handleError: (error, stackTrace, sink) {
    sink.addError('Error Detected: $error');
  },
  handleDone: (sink) {
    sink.close();
  },
);

void runChatApp() {
  final controller = StreamController<String>();

  // Connecting the stream with the transformer before calling listen
  controller.stream
      .transform(profanityTransformer)
      .listen((cleanMessage) => print('Clean Message: $cleanMessage'));

  controller.sink.add('This is a profane sentence sent.');
  controller.close();
}

Preventing Memory Leaks #

Every time you call the .listen() method on a stream, Dart allocates memory for a StreamSubscription object. If this subscription isn’t explicitly cancelled when the UI object or Controller is destroyed, the memory reference stays held in the background. This event triggers a memory leak that slowly exhausts the user’s device RAM and eventually crashes the app.

// ANTI-PATTERN: Opening a Stream subscription without ever cancelling it
class BadWidgetState {
  void initConnection() {
    // This subscription will keep running forever in memory
    // even if this Widget page has been closed by the user!
    gpsService.locationStream.listen((location) {
      print('Location: $location');
    });
  }
}

// ====================================================================

// CORRECT: Disciplined cancellation when destroyed
class GoodWidgetState {
  StreamSubscription<Location>? _locationSubscription;

  void initConnection() {
    _locationSubscription = gpsService.locationStream.listen((location) {
      print('Location: $location');
    });
  }

  void dispose() {
    // Safely shutting down the subscription connection
    _locationSubscription?.cancel();
  }
}

Integrating Streams into the Flutter UI #

Flutter provides a very powerful built-in widget called StreamBuilder. This widget automatically listens to a stream, rebuilds the UI every time new data arrives, and automatically cancels the subscription when the widget is removed from the screen (widget tree).

Here’s a complete implementation example of a reactive countdown indicator widget using StreamBuilder:

import 'package:flutter/material.dart';

class CountdownWidget extends StatefulWidget {
  const CountdownWidget({super.key});

  @override
  State<CountdownWidget> createState() => _CountdownWidgetState();
}

class _CountdownWidgetState extends State<CountdownWidget> {
  // Storing the stream reference so it isn't recreated when build is called
  late final Stream<int> _countdownStream;

  @override
  void initState() {
    super.initState();
    _countdownStream = _createCountdownStream(10);
  }

  Stream<int> _createCountdownStream(int start) async* {
    for (int i = start; i >= 0; i--) {
      await Future.delayed(const Duration(seconds: 1));
      // Sending a value to update the UI
      yield i;
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Async Countdown'),
      ),
      body: Center(
        child: StreamBuilder<int>(
          stream: _countdownStream,
          builder: (context, snapshot) {
            // 1. Handling if an error occurs in the stream data flow
            if (snapshot.hasError) {
              return Text(
                'An Error Occurred: ${snapshot.error}',
                style: const TextStyle(color: Colors.red, fontSize: 20),
              );
            }

            // 2. Checking the stream's active connection status
            switch (snapshot.connectionState) {
              case ConnectionState.none:
                return const Text('Stream not connected.');
              
              case ConnectionState.waiting:
                // Shown at the start of the connection before the first data is emitted
                return const CircularProgressIndicator();
              
              case ConnectionState.active:
                // Shown every time new data arrives (active)
                return Text(
                  'Time Remaining: ${snapshot.data}',
                  style: const TextStyle(fontSize: 48, fontWeight: FontWeight.bold),
                );
              
              case ConnectionState.done:
                // Shown after the stream channel officially closes
                return const Text(
                  'Time is Up! Done.',
                  style: TextStyle(fontSize: 32, color: Colors.green),
                );
            }
          },
        ),
      ),
    );
  }
}

By using StreamBuilder, you avoid boilerplate code like writing setState manually, opening initState blocks, and closing subscriptions inside dispose blocks. All those async lifecycles are safely handled by Flutter under the hood.

Summary #

  • Dart’s Execution Model: Dart uses a single-threaded model based on the Event Loop. Async operations run non-blocking without triggering traditional multi-threading synchronization problems.
  • Event Loop: Manages two queues: the Microtask Queue (high priority for internal Dart tasks) and the Event Queue (normal priority for I/O, UI rendering, and user input).
  • Future: A promise of a result value available in the future. Has Uncompleted, Completed with Value, and Completed with Error states.
  • async/await: Modern syntax acting as syntactic sugar on top of the Future object, making async flows written like synchronous code.
  • Parallelism: Running async operations in parallel using Future.wait or tuple .wait (Dart 3+) can significantly cut total app wait time.
  • Stream: A continuous data flow sending values multiple times over time. Divided into Single-Subscription Streams (one listener) and Broadcast Streams (many listeners).
  • StreamController: The main control tool separating the data entry point (sink) and data exit point (stream).
  • Memory Leaks: Always call .cancel() on StreamSubscription objects or .close() on StreamController to prevent memory leaks.
  • StreamBuilder: A highly recommended Flutter widget for consuming Stream data directly in the Widget Tree automatically and safely.

← Previous: Null Safety   Next: Dart 3 Features →

About | Author | Content Scope | Editorial Policy | Privacy Policy | Disclaimer | Contact