Flutter Isolate并发编程

/**
 * Concurrent programming using _isolates_:
 * independent workers that are similar to threads
 * but don't share memory,
 * communicating only via messages.
 *
 * To use this library in your code:
 *
 *     import 'dart:isolate';
 *
 * {@category VM}
 */

Isolate isolate;

// 启动新的Isolate，并监听消息
start() async {
  ReceivePort receivePort = ReceivePort();
  isolate = await Isolate.spawn(entryPoint, receivePort.sendPort, debugName: 'newIsolate');

  receivePort.listen((message) {
    debugPrint('${Isolate.current.debugName}: receive msg $message');
  });
  debugPrint('${Isolate.current.debugName}: spawn');
}

// 新Isolate入口函数
entryPoint(SendPort sendPort) {
  int counter = 0;
  Timer.periodic(Duration(seconds: 1), (Timer t) {
    debugPrint('${Isolate.current.debugName}: send msg ${counter++}');
    sendPort.send(DateTime.now());
  });
}

// 结束Isolate
void stop() {
  if (isolate != null) {
    isolate.kill(priority: Isolate.immediate);
    isolate = null;
    debugPrint('${Isolate.current.debugName}: killed isolate');
  }
}

Isolate.current.kill(priority: Isolate.immediate);

import 'dart:async';
import 'dart:isolate';

main(List<String> args, SendPort message) {
  entryPoint(message);
}

entryPoint(SendPort sendPort) {
  int counter = 0;
  Timer.periodic(Duration(seconds: 1), (Timer t) {
    print('${Isolate.current.debugName}: send msg ${counter++}');
    sendPort.send(DateTime.now());
  });
}

Future<List<Photo>> fetchPhotos(http.Client client) async {
  final response =
      await client.get('https://jsonplaceholder.typicode.com/photos');
  return compute(parsePhotos, response.body);
}

List<Photo> parsePhotos(String responseBody) {
  final parsed = json.decode(responseBody);
  return parsed.map<Photo>((json) => Photo.fromJson(json)).toList();
}

import 'dart:async';

import '_isolates_io.dart'
  if (dart.library.html) '_isolates_web.dart' as _isolates;

/// Signature for the callback passed to [compute].
///
/// {@macro flutter.foundation.compute.types}
///
/// Instances of [ComputeCallback] must be top-level functions or static methods
/// of classes, not closures or instance methods of objects.
///
/// {@macro flutter.foundation.compute.limitations}
typedef ComputeCallback<Q, R> = FutureOr<R> Function(Q message);

// The signature of [compute].
typedef _ComputeImpl = Future<R> Function<Q, R>(ComputeCallback<Q, R> callback, Q message, { String debugLabel });

/// Spawn an isolate, run `callback` on that isolate, passing it `message`, and
/// (eventually) return the value returned by `callback`.
///
/// This is useful for operations that take longer than a few milliseconds, and
/// which would therefore risk skipping frames. For tasks that will only take a
/// few milliseconds, consider [scheduleTask] instead.
///
/// {@template flutter.foundation.compute.types}
/// `Q` is the type of the message that kicks off the computation.
///
/// `R` is the type of the value returned.
/// {@endtemplate}
///
/// The `callback` argument must be a top-level function, not a closure or an
/// instance or static method of a class.
///
/// {@template flutter.foundation.compute.limitations}
/// There are limitations on the values that can be sent and received to and
/// from isolates. These limitations constrain the values of `Q` and `R` that
/// are possible. See the discussion at [SendPort.send].
/// {@endtemplate}
///
/// The `debugLabel` argument can be specified to provide a name to add to the
/// [Timeline]. This is useful when profiling an application.
// Remove when https://github.com/dart-lang/sdk/issues/37149 is fixed.
// ignore: prefer_const_declarations
final _ComputeImpl compute = _isolates.compute;

final Isolate isolate = await Isolate.spawn<_IsolateConfiguration<Q, FutureOr<R>>>(
  _spawn,
  _IsolateConfiguration<Q, FutureOr<R>>(
    callback,
    message,
    resultPort.sendPort,
    debugLabel,
    flow.id,
  ),
  errorsAreFatal: true,
  onExit: resultPort.sendPort,
  onError: errorPort.sendPort,
);
final Completer<R> result = Completer<R>();
errorPort.listen((dynamic errorData) {
  assert(errorData is List<dynamic>);
  assert(errorData.length == 2);
  final Exception exception = Exception(errorData[0]);
  final StackTrace stack = StackTrace.fromString(errorData[1]);
  if (result.isCompleted) {
    Zone.current.handleUncaughtError(exception, stack);
  } else {
    result.completeError(exception, stack);
  }
});
resultPort.listen((dynamic resultData) {
  assert(resultData == null || resultData is R);
  if (!result.isCompleted)
    result.complete(resultData);
});