Multithreading effectively in Flutter

1. –A wise man
“True judge of courage is when you get to stand between a
man and his food”

2. Speaker Bio
I work at Fueled
Psst!You can too ｡◕‿◕｡

3. Isolating Flutter into
multithreading effectively
Anvith Bhat
@anv1th

4. Exploring Rx Dart

5. Exploring Rx Dart
1. Observables can be subscribed only once.
2. onListen (doOnSubscribe) called once.
3. No Schedulers ¯_(ツ)_/¯

6. Android to Flutter
override fun updateUi(state: ViewState) {
}
@override
Widget build(BuildContext context) {
return Container(child: _content(context));
}
Widget _content(BuildContext context) {
}
if (state.isOnboardingCompleted) {
showPermissionDialog()
}
progress.visibility = if(state.isLoading){
View.VISIBLE
} else {
View.GONE
}
if(data.isOnboardingCompleted){
showPermissionDialog();
}
if (data.state == LoadState.LOADING) {
return Center(
child: CircularProgressIndicator(),
);
} else {
return _Body();
}

8. @override
Widget build(BuildContext context) {
return Container(child: _content(context));
}
Widget _content(BuildContext context) {
}
if(data.isOnboardingCompleted){
showPermissionDialog();
}
@override
Widget build(BuildContext context) {
return Container(child: _content(context));
}
Widget _content(BuildContext context) {
}
if(data.isOnboardingCompleted){
Future(()=>
showPermissionDialog());
}

10. Flutter Framework

11. Flutter Framework
• Flutter engine does not create its own threads or
manage them
Platform Task
Runner
UI Task
Runner
IO Task
Runner
GPU Task
Runner
Embedder

12. Load Costs
Accessible Load Behaviour
Platform Task Runner Yes
Gesture events dropped
and app termination
UI Task Runner Yes Frame dropping/jank
IO Task Runner No Delayed Futures
GPU Task Runner No Frame dropping/jank

13. Flutter Thread Quirks
• Threading Api is implicit.
• Futures and Async/Await solve problems of asynchrony not
computation.

14. Isolates

15. • Don't share memory.
• Data wired is copied
• Parents can limit abilities of isolates.
IsolatesAttributes

16. Isolates
Threads Looper

17. Control
Port
Capability
SendPort ReceivePort
pause/resume/killIsolate
Anatomy

18. Isolate Port
spawn(port)
PortApp
send/listen

19. How do I make em 🤔
Future<int> startIsolate() async {
}
1. Isolate.spawn(runnable, runnable_param)
//Create a Port for communication
ReceivePort receivePort = ReceivePort();
//Create the isolate
await Isolate.spawn(computeMatrix,
receivePort.sendPort);
//Pick first item in stream
return await receivePort.first;
//Callback
void computeMatrix(SendPort port) {
var result = heavilyComputedValue();
port.send(result)
}
void onButtonClick() {
startIsolate().then((computedValue) {
setState(() {
computedText = "Matrix result is
${computedValue}";
});
});
}

20. How do I make em 🤔
void createRestrictedIsolate(Isolate main){
//Proxy
Isolate restrictedIsolate = new Isolate(main.controlPort);
untrustedCode(restrictedIsolate);
}
1. Isolate.spawn(callback, callback_param)
2. via Constructor

21. How do I make em 🤔
1. Isolate.spawn(callback, callback_param)
3. spawnUri(Uri uri, List<String> args)
Future<void> executeFileContent(Isolate main) async{
var args =List<String>();
args.add("type=monthly_data");
var isolate = await Isolate.spawnUri('./periodic_sync.dart',args)
}
2. via Constructor

22. Processing Large Data
• Flutter copies data on the parent isolate.
• TransferableTypedData creates cross isolate transferrable
buffer.

23. void sendData(SendPort replyPort){
}
void receiveData(ReceivePort receivePort) async {
}
dynamic x = new ByteData(2 * 1024 * 1024);
for (int i = 0; i < 4; i++) {
x.setInt8(i, i);
}
replyPort.send(TransferableTypedData.fromList([x.buffer.asUint8List()]));
var first = await receivePort.first as TransferableTypedData;
var data = first.materialize().asByteData();

24. Benchmarks
• Spawn time for a typical isolate varies between 10-80ms
• Each isolate is allocated an independent heap. Around 5-6 mb
on a higher end phone.
• Isolate creation times on android are almost 8-10x of ios.

26. Advanced Usages
• Object Registry
• Isolate Runner
• Load balancers
pub:isolate

27. Isolate Runner
• Allows one to check if the runner is still alive.
• Specify timeouts via. run function
Wrapper around creation of Isolates.
Future<R> run<R, P>(FutureOr<R> function(P argument), P argument,
{Duration timeout}) {

28. Load Balancers
• Create and Manage Isolate runner pool.
var balancer = LoadBalancer.create(POOL_SIZE, IsolateRunner.spawn)
balancer.run(heavyCompute, heavyComputeArg, estimatedLoad)

29. Isolate + Streams
getMatrixObservable()
.asyncMap(startIsolate)
.listen((data){
print("Me gots data")
});
- asyncMap
Future<int> startIsolate(int a) async {
ReceivePort receivePort = ReceivePort();
Isolate isolate = await Isolate.spawn(isolateTask, receivePort.sendPort);
return await receivePort.first;
}

30. Isolate + Streams
- fromFuture
- asyncMap
Future<int> startIsolate() async {
ReceivePort receivePort = ReceivePort();
Isolate isolate = await Isolate.spawn(isolateTask, receivePort.sendPort);
return await receivePort.first;
}
Observable
.fromFuture(startIsolate())
.listen((data){
print("I come from the future: $data")
});;

31. An Idiomatic Spell
• Stream transformers operator
could help out
Observable.just(value)
.observeOn(Schedulers.io())

32. class IoScheduler<S, T> implements StreamTransformer<S, T> {
}

33. class IoScheduler<S, T> implements StreamTransformer<S, T> {
}
if (_loadBalancer == null) {
_loadBalancer = await LoadBalancer.create(POOL_SIZE, IsolateRunner.spawn);
}
// Create isolate pool
static Future<void> initLoadBalancer() async {
// Isolate pool state
static LoadBalancer _loadBalancer;
static const int POOL_SIZE = 6;
}

34. class IoScheduler<S, T> implements StreamTransformer<S, T> {
}
// Initialise stream handlers
IoScheduler(S isolateCode(T value)) {
}
_transformer = isolateCode;
_controller = new StreamController<T>(
onListen: _onListen
);
Function _transformer;
Future<void> initLoadBalancer() async {..}

35. class IoScheduler<S, T> implements StreamTransformer<S, T> {
}
// Initialise stream handlers
IoScheduler(S isolateCode(T value)) {..}
Function _transformer;
}
void _onListen() {
_subscription = _stream.listen(
onData,
onError: _controller.addError
);
Future<void> initLoadBalancer() async {..}

36. class IoScheduler<S, T> implements StreamTransformer<S, T> {
}
..}void _onListen() {
void onData(S data) {
initLoadBalancer().then((val) {
});
}
_loadBalancer.run(_transformer, data).then((transformed) {
_controller.add(transformed as T);
}, onError: (error) {
throw error;
});
// Initialise stream handlers
IoScheduler(S isolateCode(T value)) { ..}
Function _transformer;
Future<void> initLoadBalancer() async {..}

37. The Final Spell
Observable getFibonnaciValue(int value) {
return Observable.just(value)
.transform(IoScheduler<int, int>(calculateFib));
}
int calculateFib(int n) {
if (n <= 1)
return n;
else
return calculateFib(n - 1) + calculateFib(n - 2);
}

38. The "not so good" parts
• Copy overheads*
• Isolate creation times are sporadic.
• Doesn't guarantee true parallelism all the time. Since they're
backed byVM thread pool.

39. Takeaways
• Avoid isolates for simpler tasks like object transformations.
• Use Isolates for json decoding, encryption and image processing.
• Figure out a pool size that works well for your app. Around 5-6
isolates are good enough for most apps.
• Profile your app.

40. Resources
• IoScheduler/IoTransformer
https://gist.github.com/humblerookie/9b395f653a81cca17280921175064232
• Isolates Playground
https://github.com/humblerookie/isolates-playground/

41. Questions?
Thanks.
Anvith Bhat
@anv1th