在单个异步函数中将重复发送/响应封装到同一Dart隔离中

Question

是否可以在单个异步函数中将重复发送/响应封装到相同的dart隔离中？

背景：

为了设计一个方便的API，我想让一个函数异步返回由隔离产生的结果，例如

var ans = await askIsolate(isolateArgs);

如果我直接使用spawnUri调用生成的响应，则可以正常工作，例如

Future<String> askIsolate(Map<String,dynamic> isolateArgs) {

ReceivePort response = new ReceivePort();
var uri = Uri.parse(ISOLATE_URI);

Future<Isolate> remote = Isolate.spawnUri(uri, [JSON.encode(isolateArgs)], response.sendPort);
return remote.then((i) => response.first)
               .catchError((e) { print("Failed to spawn isolate"); })
               .then((msg) => msg.toString());
}

但是，上述方法的缺点是，如果我需要重复调​​用askIsolate，则必须每次都产生隔离。

相反，我想与正在运行的隔离进行通信，这当然可以通过使隔离将sendPort返回给调用方来实现。 但是我相信，自从2013年Isolate重构以来，这要求调用者在receivePort上侦听后续消息，从而使封装在单个异步函数中成为不可能。

有什么机制可以实现我所缺少的吗？

Answer 1

答案取决于您打算如何使用隔离器

• 您是否打算使其无限期运行，向其发送输入并期望异步接收答案？

• 您是否要一次发送隔离器许多（但有限的）输入，期望异步接收答案，然后关闭隔离器？

我猜是后者，并且您的askIsolate()函数需要立即返回一个Future不是在接收所有答案时完成该函数。

await for循环可用于侦听流并消耗事件，直到关闭为止。

我对隔离株不熟悉，所以我希望这没问题，我尚未测试过。 我假设隔离终止并且响应关闭。

String askIsolate(Map<String,dynamic> isolateArgs) async {

  ReceivePort response = new ReceivePort();
  var uri = Uri.parse(ISOLATE_URI);

  Isolate.spawnUri(uri, [JSON.encode(isolateArgs)], response.sendPort)
    .catchError((e)) {
     throw ...;
   });

  List<String> answers = new List<String>;

  await for(var answer in response) {
    out.add(answer.toString());
  }

  return answers;
}

注意：

• response是您正在听的答案流。 它是在产生隔离对象之前创建的，因此您无需（而且可能不应）等待隔离对象的将来完成之前就可以收听它。

• 我使askIsolate()异步，是因为它使立即返回一个在函数返回时完成的将来变得非常容易-无需对.then(...)链进行所有繁琐的处理.then(...)我个人觉得这很令人困惑且难以阅读。

顺便说一句，您的原始then(...).catchError(...)样式代码最好像这样编写：

  Isolate.spawnUri(uri, [JSON.encode(isolateArgs)], response.sendPort)
    .catchError((e) { ... });

   return response.first)
     .then((msg) => msg.toString());

我相信，在创建隔离符后延迟将catchError处理程序附加到该行可能会使将来在处理程序到位之前完成一个错误。

请参阅： https : //www.dartlang.org/articles/futures-and-error-handling/#potential-problem-failing-to-register-error-handlers-early 。

Answer 2

我还建议查看package:isolate中的IsolateRunner ，它旨在解决此类问题-在同一个隔离中多次调用一个函数，而不是在创建隔离时一次。

如果您不想要，还有其他更原始的选择

异步功能可以等待期货或流，而ReceivePort是流。 对于快速破解，您可能可以在响应流中await for一些操作，但这并不是很方便。

从package:async将StreamQueue的ReceivePort package:async是一个更好的选择。 这样您就可以将单个事件转换为期货。 就像是：

myFunc() async {  
  var responses = new ReceivePort();
  var queue = new StreamQueue(responses);
  // queryFunction sends its own SendPort on the port you pass to it.
  var isolate = await isolate.spawn(queryFunction, [], responses.sendPort);
  var queryPort = await queue.next();
  for (var something in somethingToDo) {
    queryPort.send(something);
    var response = await queue.next();
    doSomethingWithIt(response);
  }
  queryPort.send("shutdown command");  
  // or isolate.kill(), but it's better to shut down cleanly.
  responses.close();  // Don't forget to close the receive port.
}

Answer 3

下面是一个基于lrn的评论的快速工作示例。 该示例通过spawnURI初始化一个隔离，然后通过传递一个新的ReceivePort与隔离进行通信，期望在该接收端口上进行回复。 这允许askIsolate直接从运行中的spawnURI隔离返回响应。

注意为清楚起见已省略了错误处理。

隔离代码：

import 'dart:isolate';
import 'dart:convert' show JSON;

main(List<String> initArgs, SendPort replyTo) async {
  ReceivePort receivePort = new ReceivePort();
  replyTo.send(receivePort.sendPort);

  receivePort.listen((List<dynamic> callArgs) async {
    SendPort thisResponsePort = callArgs.removeLast(); //last arg must be the offered sendport
    thisResponsePort.send("Map values: " + JSON.decode(callArgs[0]).values.join(","));
  });
}

调用代码：

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


const String ISOLATE_URI = "http://localhost/isolates/test_iso.dart";
SendPort isolateSendPort = null;

Future<SendPort> initIsolate(Uri uri) async {
    ReceivePort response = new ReceivePort();
    await Isolate.spawnUri(uri, [], response.sendPort, errorsAreFatal: true);
    print("Isolate spawned from $ISOLATE_URI");
    return await response.first;
}


Future<dynamic> askIsolate(Map<String,String> args) async {
  if (isolateSendPort == null) {
    print("ERROR: Isolate has not yet been spawned");
    isolateSendPort = await initIsolate(Uri.parse(ISOLATE_URI)); //try again
  }

  //Send args to the isolate, along with a receiveport upon which we listen for first response 
  ReceivePort response = new ReceivePort();
  isolateSendPort.send([JSON.encode(args), response.sendPort]);
  return await response.first;
}

main() async {
  isolateSendPort = await initIsolate(Uri.parse(ISOLATE_URI));

  askIsolate({ 'foo':'bar', 'biz':'baz'}).then(print);
  askIsolate({ 'zab':'zib', 'rab':'oof'}).then(print);
  askIsolate({ 'One':'Thanks', 'Two':'lrn'}).then(print);
}  

输出量

Isolate spawned from http://localhost/isolates/test_iso.dart
Map values: bar,baz
Map values: zib,oof
Map values: Thanks,lrn