Concurrency

Isolate ile paralel işleme eklersin.

Isolate ile paralel hesap

Isolate, Dart'ın paralel çalışma birimidir. Dart tek iş parçacıklıdır (single-threaded); ağır hesap ana iş parçacığını bloklar. Isolate.run bir işlevi ayrı bir isolate'de çalıştırır ve sonuçu Future olarak döndürür.

Örnek: Future<int> heavyCompute(int n) { return Isolate.run(() => fib(n)); }. Burada fib(n) ayrı isolate'de hesaplanır; ana iş parçacığı serbest kalır. Isolate'ler bellek paylaşmaz; her biri kendi yığınına sahiptir. Bu nedenle veri kopyalanarak aktarılır. Ağır CPU işleri (büyük hesap, görüntü işleme) isolate'e taşınır; böylece arayüz akıcı kalır.

heavyCompute deseni

heavyCompute, ağır fibonacci hesabını isolate'de çalıştıran fonksiyondur. fib öz-günlü (naive) yazımda yavaştır; büyük n için ana iş parçacığını döndürür. Isolate.run ile bu yük arka plana taşınır.

Örnek: int fib(int n) { if (n < 2) return n; return fib(n-1) + fib(n-2); } ve Future<int> heavyCompute(int n) { return Isolate.run(() => fib(n)); }. fib(10) = 55 deterministiktir. heavyCompute bir Future döndürür; await ile beklenir. Bu desen, arayüzü akıcı tutarken arka planda hesap yapmanın standart yoludur.

Uygulama fib ve heavyCompute

import 'dart:isolate'; satırını en üste ekle. int fib(int n) fonksiyonunu yaz: n < 2 ise n döndür, değilse fib(n-1) + fib(n-2) döndür. Future<int> heavyCompute(int n) fonksiyonu yaz; içinde return Isolate.run(() => fib(n)); yap. main içine print('Isolate: heavyCompute hazır') ve print('fib(10): ${fib(10)}') ekle.

Örnek çözümü göster

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: 'görev 1')];
}

Response taskHandler(Request req, TaskService svc) {
  return Response.ok('görevler: ${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 hazır');
  print('fib(10): ${fib(10)}');
}

Kendini test et

Isolate.run ne sağlar?
- Şifreleme
- Paralel hesaplama
- Sıkıştırma
- Serileştirme
Cevabı göster

Paralel hesaplama — Isolate.run paralel hesaplama sağlar.
Isolate parçalarını eşleştir

Isolate

İşçi
run

Başlatır
fib

Fibonacci
heavyCompute

Ağır hesap

Isolate.run çağrısı

return Isolate.____(() => fib(n));

Cevabı göster

return Isolate.run(() => fib(n));

Sıradaki ders: Birleştirme

Deneyiminizi Geliştiriyoruz

Çerez Tercihleri

Kesinlikle Gerekli Çerezler

Analitik Çerezler