不变性和性能

Question

我尝试搜索 stackoverflow 并且有许多相关主题，包括

val-mutable versus var-immutable in Scala

What is the difference between a var and val definition in Scala?

但我还是想澄清一下我的理解是否正确。

看起来规则正在遵循

更喜欢不可变的 val 而不是不可变的 var 而不是可变的 val 而不是可变的 变种。尤其是不可变 var 优于可变 val！

但不可变 var 的性能比可变 val 差得多，根据 REPL 中的简单测试

scala -J-Xmx2g

scala> import scala.collection.mutable.{Map => MMap}
import scala.collection.mutable.{Map=>MMap}

scala>

scala> def time[R](block: => R): R = {
     |   val t0 = System.nanoTime()
     |   val result = block    // call-by-name
     |   val t1 = System.nanoTime()
     |   println("Elapsed time: " + (t1 - t0) + "ns")
     |   result
     | }
time: [R](block: => R)R

scala>time {val mut_val = MMap[Int, Int](); for (i <- 1 to 1000000) mut_val += (i -> i)}
Elapsed time: 551073900ns

scala>time {var mut_var = MMap[Int, Int](); for (i <- 1 to 1000000) mut_var += (i -> i)}
Elapsed time: 574174400ns

scala>time {var imut_var = Map[Int, Int](); for (i <- 1 to 1000000) imut_var += (i -> i)}
Elapsed time: 860938800ns

scala>time {val mut_val = MMap[Int, Int](); for (i <- 1 to 2000000) mut_val += (i -> i)}
Elapsed time: 1103283000ns

scala>time {var mut_var = MMap[Int, Int](); for (i <- 1 to 2000000) mut_var += (i -> i)}
Elapsed time: 1166532600ns

scala>time {var imut_var = Map[Int, Int](); for (i <- 1 to 2000000) imut_var += (i -> i)}
Elapsed time: 2926954500ns

我还添加了 mutable var，即使很难，它也没有多大意义。 它的性能与 mutable val 非常相似，只是为了完成图片。 但是不可变 var 的性能要差得多。

因此，不可变 var 与可变 val 的代价是性能下降（以及更广泛的内存使用！）。有人可以再次解释支付这个价格的意义是什么吗？具体例子表示赞赏。

谢谢

Answer 1

有很多方法可以回答这个问题（许多 cmets 驳斥了可变 val 总是表现更差的说法），但一句话概括：范围和副作用。

不可变 var 的范围仅限于声明它的位置，并且将其作为参数传递或将其分配给另一个变量通常会按预期运行。
另一方面，可变 val 会感受到状态的变化，无论它在哪里使用和传递。

考虑一个应用程序，您希望在其中运行多个具有不同配置的工作程序，这些工作程序继承自默认值。 （假设TIMEOUT_1 = t1 和PARALLEL_FACTOR_1 = pf1 和TIMEOUT_2 = t2 等）

使用不可变变量

var defaultConfig = immutable.Map("timeout" → "5", "parallelFactor" → "4")
var worker1Config = defaultConfig
var worker2Config = defaultConfig

worker1Config += "timeout" → sys.env("TIMEOUT_1")
worker1Config += "parallelFactor" → sys.env("PARALLEL_FACTOR_1")

worker2Config += "timeout" → sys.env("TIMEOUT_2")
worker2Config += "parallelFactor" → sys.env("PARALLEL_FACTOR_2")

println(defaultConfig) // Map(timeout -> 5, parallelFactor -> 4)
println(worker1Config) // Map(timeout -> t1, parallelFactor -> pf1)
println(worker2Config) // Map(timeout -> t2, parallelFactor -> pf2)

可变变量

val defaultConfig = mutable.Map("timeout" → "5", "parallelFactor" → "4")
val worker1Config = defaultConfig
val worker2Config = defaultConfig

worker1Config += "timeout" → sys.env("TIMEOUT_1")
worker1Config += "parallelFactor" → sys.env("PARALLEL_FACTOR_1")

worker2Config += "timeout" → sys.env("TIMEOUT_2")
worker2Config += "parallelFactor" → sys.env("PARALLEL_FACTOR_2")

println(defaultConfig) // Map(parallelFactor -> pf2, timeout -> t2)
println(worker1Config) // Map(parallelFactor -> pf2, timeout -> t2)
println(worker2Config) // Map(parallelFactor -> pf2, timeout -> t2)

您可以看到，即使几乎所有代码都相同，但使用可变 val 会引入一个不明显的错误（尤其是如果这些代码部分位于不同的函数中而不是全部在一起时）。