Flutter动画效果插件actors的使用

概述

actors 是一个允许在Dart中使用Actor模型的库。它是一个轻量级的包装器，围绕着Dart的 Isolate（在Flutter和Dart VM上）和Web Workers（在Web上 - 待办事项），使它们更易于使用。

Actor

创建和启动一个Actor非常简单。你只需要创建一个实现了处理消息逻辑的 Handler，然后使用它来创建一个 Actor。

class Accumulator with Handler<int, int> {
  int _value;

  Accumulator([int initialValue = 0]): _value = initialValue;

  int handle(int n) => _value += n;
}

main() async {
  final actor = Actor.create(() => Accumulator(6));
  print(await actor.send(5)); // 11
  await actor.close();
}

如果你的actor不需要维护内部状态，也可以从函数或lambda表达式创建：

int two(int n) => n * 2;

main() async {
  final actor = Actor.of(two);
  print(await actor.send(5)); // 10
  await actor.close();
}

StreamActor

如果需要返回多个消息，可以使用 StreamActor，它可以从 Handler 返回 Stream。

class StreamGenerator with Handler<int, Stream<int>> {
  @override
  Stream<int> handle(int message) {
    return Stream.fromIterable(Iterable.generate(message, (i) => i));
  }
}

main() async {
  final actor = StreamActor.create(StreamGenerator.new);
  final stream = actor.send(2);
  await for (final item in stream) {
    print(item); // 0, 1
  }
  await actor.close();
}

Actor状态

Actor可以在自己的Dart Isolate中安全地维护内部状态，这些状态不能被其他actor访问。状态可以包括任何内容，甚至是 Stream 和打开的socket。初始状态可以通过 Handler 的 init 方法进行异步初始化。

class HttpServerActor with Handler<Message, Answer> {
  late final HttpServer _server;
  final int port;

  HttpServerActor(this.port);

  @override
  Future<void> init() async {
    _server = await HttpServer.bind(InternetAddress.loopbackIPv4, port, shared: true);
    unawaited(_serveRequests());
  }

  // ...
}

ActorGroup

ActorGroup 允许将多个 Actor 实例分组在一起，所有实例都基于相同的 Handler 实现，但根据可用策略执行：

• RoundRobin：轮流发送消息给单个 Actor。
• MultiHandler：发送消息给 m 个 Actor，等待至少 n 个成功的响应。

// 创建一个包含4个actor的组
final group = ActorGroup(Two(), size: 4);
print(await group.send(5)); // 10
group.close();

Messenger

Messenger 混入由 Actor、ActorGroup 和 LocalMessenger 实现，后者在其本地 Isolate 中运行其 Handler。

Messenger<int, int> messenger;

// 可以是本地的
messenger = LocalMessenger(Two());
print(await messenger.send(2)); // 4

// 或者是一个Actor
messenger = Actor(Two());
print(await messenger.send(3)); // 6
messenger.close();

// 或者是一个ActorGroup
messenger = ActorGroup(Two(), size: 2);
print(await messenger.send(4)); // 8
print(await messenger.send(5)); // 10
messenger.close();

更多示例

• basic_example.dart：演员的基本用法。
• actors_example.dart：使用演员、组、流和本地。
• example-projects/word_count：用于统计文件中单词数量的工具。

完整示例代码

import 'dart:async';
import 'dart:core';
import 'dart:io';
import 'dart:isolate';

import 'package:actors/actors.dart';

/// Example actor that keeps a counter as its state.
///
/// All it takes for a Dart class to become an Actor is for it to
/// mixin [Handler] and be instantiated like:
///
/// ```dart
/// final actor = Actor(Counter());
/// ```
class Counter with Handler<int, int> {
  int _count = 0;

  @override
  int handle(int n) => _count += n;
}

/// Expected printed output from the main function.
Iterator<String> _expectedLines = [
  // Actors example
  '1', '2', '8', '16', //
  // ActorGroup example
  '10', '12', '14', '16', '18', '20', //
  // StreamActor example
  '0', '1', //
  // LocalMessenger example
  '2', '3', '8', '10', //
].iterator;

// This function overrides Dart's "print" so we can verify the printed output
void printAndCheck(Zone self, ZoneDelegate parent, Zone zone, String line) {
  _expectedLines.moveNext();
  if (line == _expectedLines.current) {
    stdout.writeln(line);
  } else {
    throw Exception('Unexpected line: $line, not ${_expectedLines.current}');
  }
}

void main() async {
  await runZoned(() async {
    await actorExample();
    await actorGroupExample();
    await streamActorExample();
    await localMessengerExample();
  }, zoneSpecification: ZoneSpecification(print: printAndCheck));
}

Future actorExample() async {
  stdout.writeln('Actor example');

  // Create an Actor from a Handler
  final actor = Actor.create(Counter.new);
  print(await actor.send(1)); // 1
  print(await actor.send(1)); // 2
  print(await actor.send(6)); // 8
  print(await actor.send(8)); // 16

  // Close the actor to stop its Isolate
  await actor.close();
}

int times2(int n) {
  // print the name of the current Isolate for debugging purposes
  stdout.write(
      '${Isolate.current.debugName?.padRight(8) ?? 'Isolate'} - times2($n)\n');
  return n * 2;
}

Future actorGroupExample() async {
  stdout.writeln('ActorGroup example');

  // create a group of 4 actors from a simple top-level function...
  // in this example, any of the actors in the group could handle a
  // particular message (default behaviour is to use round-robin),
  // and as we don't wait before sending the next message,
  // messages are handled concurrently!
  final group = ActorGroup.of(times2, size: 4);

  // send a bunch of messages and remember the Futures with answers
  final answers =
      Iterable.generate(6, (index) => index + 5).map(group.send).toList();

  // print each response (type shown explicitly for clarity)
  for (FutureOr<int> answer in answers) {
    print(await answer); // prints 10, then 12, 14, 16, 18, 20
  }

  // closing the group will cause any pending message deliveries to fail!
  await group.close();
}

// A Handler that returns a Stream must use a StreamActor, not an Actor.
class StreamGenerator with Handler<int, Stream<int>> {
  @override
  Stream<int> handle(int message) {
    return Stream.fromIterable(Iterable.generate(message, (i) => i));
  }
}

Future streamActorExample() async {
  stdout.writeln('StreamActor example');

  // Create an StreamActor from a Handler that returns Stream.
  final actor = StreamActor.create(StreamGenerator.new);
  final stream = actor.send(2);
  await for (final item in stream) {
    print(item); // 0, 1
  }
  await actor.close();
}

Future localMessengerExample() async {
  stdout.writeln('LocalMessenger example');

  Messenger<int, int> messenger;

  // a Messenger can be local
  messenger = LocalMessenger(Counter());
  print(await messenger.send(2)); // 2
  await messenger.close();

  // or it can be an Actor
  messenger = Actor.create(Counter.new);
  print(await messenger.send(3)); // 3
  await messenger.close();

  // or an ActorGroup
  messenger = ActorGroup.of(times2, size: 2);
  print(await messenger.send(4)); // 8
  print(await messenger.send(5)); // 10
  await messenger.close();
}

以上就是关于 actors 插件的详细介绍和使用方法，希望对你有所帮助。