Akka 指南 之「Akka 和 Java 内存模型」

温馨提示:Akka 中文指南的 GitHub 地址为「akka-guide」,欢迎大家StarFork,纠错。

Akka 和 Java 内存模型

使用 LightBend 平台(包括 Scala 和 Akka)的一个主要好处是简化了并发软件的编写过程。本文讨论了 LightBend 平台,特别是 Akka 如何在并发应用程序中处理共享内存。

Java 内存模型

在 Java 5 之前,Java 内存模型(JMM)是定义有问题的。当多个线程访问共享内存时,可能会得到各种奇怪的结果,例如:

  • 线程看不到其他线程写入的值:可见性问题。
  • 由于没有按预期的顺序执行指令而导致的观察其他线程发生“不可能”的行为:指令重新排序问题。

随着 Java 5 中 JSR 133 的实现,许多问题得到了解决。JMM 是基于“先于发生(happens-before)”关系的一组规则,它约束一个内存访问必须发生在另一个内存访问之前的时间,反之,当它们被允许无序发生时。这些规则的两个例子是:

  • 监视器锁规则:在每次后续获取同一锁之前,都会释放一个锁。
  • volatile变量规则volatile变量的写入发生在同一volatile变量的每次后续读取之前。

虽然 JMM 看起来很复杂,但是规范试图在易用性和编写性能、可扩展并发数据结构的能力之间找到一个平衡点。

Actors 和 Java 内存模型

通过 Akka 中的 Actor 实现,多个线程可以通过两种方式在共享内存上执行操作:

  • 如果消息发送给某个 Actor(例如由另一个 Actor)。在大多数情况下,消息是不可变的,但是如果该消息不是正确构造的不可变对象,没有“先于发生”规则,则接收者可能会看到部分初始化的数据结构,甚至可能会看到空气稀薄的值(longs/doubles)。
  • 如果 Actor 在处理消息时更改其内部状态,并在稍后处理另一条消息时访问该状态。重要的是要认识到,对于 Actor 模型,你不能保证同一线程将对不同的消息执行相同的 Actor。

为了防止 Actor 出现可见性和重新排序问题,Akka 保证以下两条“先于发生”规则:

  • Actor 发送规则:向 Actor 发送消息的过程发生在同一 Actor 接收消息之前。
  • Actor 后续处理规则:一条消息的处理发生在同一 Actor 处理下一条消息之前。

注释:在外行术语中,这意味着当 Actor 处理下一条消息时,Actor 内部字段的更改是可见的。因此,Actor 中的字段不必是volatileequivalent的。

这两个规则仅适用于同一个 Actor 实例,如果使用不同的 Actor,则这两个规则无效。

Futures 和 Java 存储模型

Future的“先于发生”调用任何注册到它的回调被执行之前。

我们建议不要关闭非final字段(Java 中的final和 Scala 中的val),如果选择关闭非final字段,则必须标记volatile,以便字段的当前值对回调可见。

如果关闭引用,还必须确保引用的实例是线程安全的。我们强烈建议远离使用锁定的对象,因为它可能会导致性能问题,在最坏的情况下还会导致死锁。这就是同步的危险。

Actors 和共享可变状态

由于 Akka 在 JVM 上运行,所以仍然需要遵循一些规则。

  • 关闭内部 Actor 状态并将其暴露给其他线程
import akka.actor.{ Actor, ActorRef }
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.Future
import scala.concurrent.duration._
import scala.language.postfixOps
import scala.collection.mutable

case class Message(msg: String)

class EchoActor extends Actor {
  def receive = {
    case msg ⇒ sender() ! msg
  }
}

class CleanUpActor extends Actor {
  def receive = {
    case set: mutable.Set[_] ⇒ set.clear()
  }
}

class MyActor(echoActor: ActorRef, cleanUpActor: ActorRef) extends Actor {
  var state = ""
  val mySet = mutable.Set[String]()

  def expensiveCalculation(actorRef: ActorRef): String = {
    // this is a very costly operation
    "Meaning of life is 42"
  }

  def expensiveCalculation(): String = {
    // this is a very costly operation
    "Meaning of life is 42"
  }

  def receive = {
    case _ ⇒
      implicit val ec = context.dispatcher
      implicit val timeout = Timeout(5 seconds) // needed for `?` below

      // Example of incorrect approach
      // Very bad: shared mutable state will cause your
      // application to break in weird ways
      Future { state = "This will race" }
      ((echoActor ? Message("With this other one")).mapTo[Message])
        .foreach { received ⇒ state = received.msg }

      // Very bad: shared mutable object allows
      // the other actor to mutate your own state,
      // or worse, you might get weird race conditions
      cleanUpActor ! mySet

      // Very bad: "sender" changes for every message,
      // shared mutable state bug
      Future { expensiveCalculation(sender()) }

      // Example of correct approach
      // Completely safe: "self" is OK to close over
      // and it's an ActorRef, which is thread-safe
      Future { expensiveCalculation() } foreach { self ! _ }

      // Completely safe: we close over a fixed value
      // and it's an ActorRef, which is thread-safe
      val currentSender = sender()
      Future { expensiveCalculation(currentSender) }
  }
}
  • 消息应该是不可变的,这是为了避免共享可变状态陷阱。

英文原文链接Akka and the Java Memory Model.


———— ☆☆☆ —— 返回 -> Akka 中文指南 <- 目录 —— ☆☆☆ ————

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 代码科技 设计师:Amelia_0503 返回首页
实付 9.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值