Dart
Concurrency
Add parallel processing with Isolate.
Parallel computation with Isolate
Isolate is Dart's parallel execution unit. Dart is single-threaded; heavy computation blocks the main thread. Isolate.run runs a function in a separate isolate and returns the result as a Future.
Example: Future<int> heavyCompute(int n) { return Isolate.run(() => fib(n)); }. Here fib(n) is computed in a separate isolate; the main thread stays free. Isolates do not share memory; each has its own heap. So data is passed by copy. Heavy CPU work (big computation, image processing) is moved to an isolate; this keeps the interface responsive.
The heavyCompute pattern
heavyCompute is the function that runs the heavy fibonacci computation in an isolate. fib is slow in the naive form; for big n it freezes the main thread. Isolate.run moves this load to the background.
Example: int fib(int n) { if (n < 2) return n; return fib(n-1) + fib(n-2); } and Future<int> heavyCompute(int n) { return Isolate.run(() => fib(n)); }. fib(10) = 55 is deterministic. heavyCompute returns a Future; it is awaited with await. This pattern is the standard way to do background computation while keeping the interface responsive.
Exercise fib and heavyCompute
Add import 'dart:isolate'; at the top. Write int fib(int n): if n < 2 return n, else return fib(n-1) + fib(n-2). Write Future<int> heavyCompute(int n) with return Isolate.run(() => fib(n)); inside. In main add print('Isolate: heavyCompute ready') and print('fib(10): ${fib(10)}').
Show example solution
import 'package:shelf/shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:sqflite/sqflite.dart';
import 'dart:isolate';
class Task {
final int id;
final String title;
Task({required this.id, required this.title});
}
abstract class TaskService {
List<Task> list();
}
class InMemoryTaskService implements TaskService {
@override
List<Task> list() => [Task(id: 1, title: 'task 1')];
}
Response taskHandler(Request req, TaskService svc) {
return Response.ok('tasks: ${svc.list().length}');
}
class SqliteTaskService {
final Database db;
SqliteTaskService(this.db);
Future<List<Task>> all() async {
final rows = await db.query('tasks');
return rows.map((r) => Task(id: r['id'] as int, title: r['title'] as String)).toList();
}
}
int fib(int n) {
if (n < 2) return n;
return fib(n - 1) + fib(n - 2);
}
Future<int> heavyCompute(int n) {
return Isolate.run(() => fib(n));
}
void main() {
print('Isolate: heavyCompute ready');
print('fib(10): ${fib(10)}');
}
Test yourself
-
What does Isolate.run provide?
- Encryption
- Parallel computation
- Compression
- Serialization
Show answer
Parallel computation — Isolate.run provides parallel computation.
-
Match the Isolate parts
- Isolate
- Worker
- run
- Starts
- fib
- Fibonacci
- heavyCompute
- Heavy compute
-
The Isolate.run call
return Isolate.____(() => fib(n));
Show answer
return Isolate.run(() => fib(n));
Next lesson: Putting it together
