Fluttering Dart

Fluttering Dart: Futures and Isolates

How to overcome the single-thread downside

Dart is single-threaded. That means that all of our application code runs in the same thread. Unfortunately, our code might block the single thread execution if it runs very time-consuming operations like HTTP requests.

Futures

Futures come in to resolve this by allowing us to perform asynchronous operations. For representing and working with the results of these operations we get the async and await keywords.

A Future<T> object provides a value, of type T, sometime in the future.

Let’s stick with our Cat class, that we used in the previous parts, and see an example from their realm:

import 'dart:math';

class Cat {
  DateTime birthday;

  Cat.baby() {
    birthday = DateTime.now();
  }

  Future<String> meow() async {
    var random = Random.secure();
    await Future.delayed(Duration(seconds: random.nextInt(10)));
    return 'Meow!';
  }
}

void main() async {
  Cat babyCat = Cat.baby();
  print('Baby cat says:');
  String babyCatMeow = await babyCat.meow();
  print('$babyCatMeow');
}

In the above example we create a baby cat. If you don’t know, cats do whatever they want, whenever they want. Meowing is no exception, and our kitten meows randomly in a 0–10 seconds interval.

The meow method of the Cat class is asynchronous. It returns a string in the future after it awaits for a random number of seconds (0–10). The Future.delayed method stops the single-thread execution for a given duration. Note that we also have to make our main asynchronous and await for the meow result.

This mechanism of an async method that awaits for a result applies whenever we need to get some data that can/should be available only in the future because of computational/logic reasons.

Isolates

Single threading on the multi-core CPU devices we have more and more around us seems a bit inefficient.

The traditional way the developers make use of all processing power of a device is by using shared-memory threads that run concurrently. This method is complicated and error-prone.

Dart uses Isolates to take advantage of all the available processing power. Isolates allow true parallel code execution and this results in improved performance and overall application responsiveness.

All Dart programs start with at least one Isolate instance and that one is the main Isolate, where all of our application code runs.

To have our code executed in parallel we must create new Isolate instances. These will run in parallel with the main Isolate. Isolates are completely independent, with their own memory heap, ensuring that no isolate’s state is accessible from any other isolate.

For establishing communication between isolates (dispatch/receive data) we need to exchange messages. These can be primitive values, such as null, num, bool, double, or String, or simple objects such as a List<Cat>. Passing more complex objects, such as a Future or http.Response between isolates might result in errors.

Isolate.spawn expects to be passed a static or top-level function.

import 'dart:math';
import 'dart:isolate';

class Cat {
  DateTime birthday;

  Cat.baby() {
    birthday = DateTime.now();
  }

  static void meow(int s) async {
    await Future.delayed(Duration(seconds: s));
    print('Meow!');
  }
}

void main() async {
  var timeInterval = 10;
  var random = Random.secure();
  for(var i=0; i<100; i++) {
    await Isolate.spawn(Cat.meow, random.nextInt(timeInterval));
  }
  await Future.delayed(Duration(seconds: timeInterval+1));
}

We modified the Cat class and transformed the meow method into a static (class) method. We also changed it to accept s, a parameter that represents the number of seconds in which the cat has to meow. This method will be used to see the Isolate at work.

In the main Isolate, we declare a time interval of 10 seconds and a random generator. We then spawn 100 Cat.meow methods in the next 10 seconds, each running in a dedicated Isolate.

We also make sure that the main Isolate runs a bit longer than the other isolates it spawned, otherwise we’ll see only the output that was spawned with 0 seconds delay.

When compiling to JavaScript, isolates get converted into web workers.

Note that this won’t work in DartPad. You can test it in a Dart/Flutter project setup in your favorite editor (I use Visual Studio Code, though there are other great options out there).

Flutter projects can use both platform-specific and cross-platform code. The latter is written in Dart, and, for building Flutter apps, some basic knowledge of Dart is required.

Fluttering Dart’s goal is to explore fundamental knowledge and unveil tips & tricks of the powerful programming language that brings Flutter to life.

In the previous parts of the series, we went through the Dart built-in data types, functions, operators, control flow statements and object-orientated programming (classes, objects and more).

In this part, we’ve discovered how to overcome the single-thread downside of Dart.

Some of the code examples from above can be tried out, and played with, using DartPad.

In the next part of the Fluttering Dart series, we’ll delve into libraries and packages, crucial for structuring, using, reusing and sharing our code.

Tha(nk|t’)s all!