Scala Akka对发件人的未来响应

我遇到了以下问题：

在通读过程中，我遇到了以下示例：

def receive = {
  case Request(data) =>
    future {
      val result = transform(data)
      sender ! Response(result)
    }
}

该文章中有以下描述：

>     Capturing sender in the above example is problematic, since it does not return a stable value. It is possible that the future’s body
> is executed at a time when the actor has started processing the next
> Request message which could be originating from a different actor. As
> a result, the Response message of the future might be sent to the
> wrong receiver.

我不完全理解这句话“在上面的例子中捕获发送者是有问题的……”这种情况下，对参与者的每个请求（请求（数据））不都会创建一个未来的块吗

未来块的创建是同步的，这意味着发送方引用在当时是已知的。只是未来块的执行被安排在稍后的时间点

我的理解正确吗

def receive = {
  case Request(data) =>
    future {
      val result = transform(data)
      sender ! Response(result)
    }
}

想象一下，行

发送者！响应（结果）

在300毫秒后执行，与封闭的参与者处理另一条消息的时间完全相同，我们称之为

M

。因为发送方是def，而不是val，所以每次使用时都会对其进行评估。这意味着，在未来的日子里，你已经拥有了

M

消息的发送者！您没有回复创建未来

的原始邮件的发件人，而是回复了其他人。要缓解此问题，您需要在创建
未来
时关闭sender（）def的值。将原始代码与以下代码进行比较：

def receive = {
  case Request(data) =>
    val client = sender()
    future {
      val result = transform(data)
      client ! Response(result)
    }
}

您已经记住了原始发件人，因此一切都是正确的

最重要的是，永远不要执行任何依赖于时间的方法（如
发送方
），也不要以异步方式更改参与者的状态。如果您需要更改参与者的状态以响应某些异步计算，则应该从
future
块向自己发送一条消息

想象一下，行
发送者！响应（结果）
在300毫秒后执行，与封闭的参与者处理另一条消息的时间完全相同，我们称之为
M
。因为发送方是def，而不是val，所以每次使用时都会对其进行评估。这意味着，在未来的日子里，你已经拥有了
M
消息的发送者！您没有回复创建未来
的原始邮件的发件人，而是回复了其他人。要缓解此问题，您需要在创建
未来
时关闭sender（）def的值。将原始代码与以下代码进行比较：

def receive = {
  case Request(data) =>
    val client = sender()
    future {
      val result = transform(data)
      client ! Response(result)
    }
}

您已经记住了原始发件人，因此一切都是正确的

最重要的是，永远不要执行任何依赖于时间的方法（如
发送方
），也不要以异步方式更改参与者的状态。如果您需要更改参与者的状态以响应某些异步计算，则应该从
future
块向自己发送一条消息

想象一下，行
发送者！响应（结果）
在300毫秒后执行，与封闭的参与者处理另一条消息的时间完全相同，我们称之为
M
。因为发送方是def，而不是val，所以每次使用时都会对其进行评估。这意味着，在未来的日子里，你已经拥有了
M
消息的发送者！您没有回复创建未来
的原始邮件的发件人，而是回复了其他人。要缓解此问题，您需要在创建
未来
时关闭sender（）def的值。将原始代码与以下代码进行比较：

def receive = {
  case Request(data) =>
    val client = sender()
    future {
      val result = transform(data)
      client ! Response(result)
    }
}

您已经记住了原始发件人，因此一切都是正确的

最重要的是，永远不要执行任何依赖于时间的方法（如
发送方
），也不要以异步方式更改参与者的状态。如果您需要更改参与者的状态以响应某些异步计算，则应该从
future
块向自己发送一条消息

想象一下，行
发送者！响应（结果）
在300毫秒后执行，与封闭的参与者处理另一条消息的时间完全相同，我们称之为
M
。因为发送方是def，而不是val，所以每次使用时都会对其进行评估。这意味着，在未来的日子里，你已经拥有了
M
消息的发送者！您没有回复创建未来
的原始邮件的发件人，而是回复了其他人。要缓解此问题，您需要在创建
未来
时关闭sender（）def的值。将原始代码与以下代码进行比较：

def receive = {
  case Request(data) =>
    val client = sender()
    future {
      val result = transform(data)
      client ! Response(result)
    }
}

您已经记住了原始发件人，因此一切都是正确的

最重要的是，永远不要执行任何依赖于时间的方法（如
发送方
），也不要以异步方式更改参与者的状态。如果您需要更改参与者的状态以响应某些异步计算，您应该从
future
块向自己发送消息。
sender
是方法而不是val。
sender
是方法而不是val。
sender
是方法而不是val。
sender
是方法而不是val。