迹忆客 专注技术分享

本文将讨论 lazy val 如何在 Scala 中工作。我们还将讨论它的一些缺点。

在 Scala 中使用 lazy val

lazy val 是一种延迟变量初始化的功能，这是 Java 程序中使用的典型模式。它也被称为按需调用评估策略，其中语句直到第一次使用才被评估，这意味着将评估推迟或推迟到需要时。

我们只需在 val 之前添加关键字 lazy 即可使用它。让我们用一个例子来看看它是如何工作的。

以下代码语句在 scala REPL 中执行。

没有 lazy：

scala> val marks = List(20,30,40,50)
val marks: List[Int] = List(20, 30, 40, 50)

scala> val doubleMarks = marks.map(temp=>temp*2)    //when we hit enter after statement , we get below result: the doubleMarks list is calculated
val doubleMarks: List[Int] = List(40, 60, 80, 100)


scala> println(doubleMarks)
List(40, 60, 80, 100)

使用 lazy：

scala> val marks = List(50,60,70,25)
val marks: List[Int] = List(50, 60, 70, 25)

scala> lazy val doubleMarks = marks.map(temp=>temp*2)
lazy val doubleMarks: List[Int] // unevaluated

scala> println(doubleMarks)
List(100, 120, 140, 50)

Scala 编译器不会立即计算 lazy val 表达式。仅在首次访问时对其进行评估。

当初始访问完成时，编译器评估表达式，然后存储（缓存）lazy val 结果。稍后我们访问它时不会执行任何操作，并且编译器会返回存储的结果。

让我们看一个关于惰性验证结果的缓存/存储的示例：

scala> lazy val statement={ println("first time access and storing it"); 1000 }
lazy val statement: Int // unevaluated

scala> println(statement)
first time access and storing it
1000

scala> println(statement)
1000

当我们第一次打印/访问该语句时，我们会得到 1000 和一个打印语句，但是当第二次访问它时，我们只会得到 1000，因为它是在变量语句中分配和存储/缓存的值。

lazy val 的无限数据结构

lazy val 可以访问无限数据结构。

在 Scala 中，我们知道列表是序列。这些列表也是严格序列意味着列表元素是预先构建的，但我们也可以创建非严格序列，其中元素是根据要求制作的。

示例代码：

object workspace {
    def main(args: Array[String]): Unit = {
        var temp = 5

        def myfun() = {
            temp += 1;
            temp
        }

        lazy val geek = Stream.continually( myfun() )

        (geek take 5) foreach {
            x => println(2*x)
        }
    }
}

输出：

12
14
16
18
20

myfun() 方法被转换为一个函数。Stream.continually() 方法创建一个无限流。

它接受该函数，并且每当访问每个元素时，仅在那时调用 myfun() 函数来执行计算。

这种按需执行的函数称为 Thunk，一旦计算完成，就会存储在缓存中以供进一步使用，这也称为记忆化。

在 Scala 中使用 lazy val 的优点

lazy val 优化了计算过程。在示例中，我们可以观察到我们浪费了映射操作（CPU 计算），这在处理更广泛和更复杂的代码时非常昂贵。

所以在这里，惰性求值通过仅在需要时评估表达式来帮助我们优化过程，避免不必要的计算。

大数据框架 Apace Spark 在处理大量数据时大量利用了此功能。lazy val 还可以访问无限数据结构。

在 Scala 中使用 lazy val 的缺点

尽管它有优点，但它也有一些缺点，因此必须谨慎使用。

lazy val 在处理多个线程时可能会导致死锁。

示例代码：

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.concurrent.duration.DurationInt

object myFirstObj {
    lazy val initialState = 50
    lazy val start = mySecondObj.initialState
}

object mySecondObj {
    lazy val initialState = myFirstObj.initialState
}

object workspace extends App {
    def run = {
        val result = Future.sequence(Seq(Future {
        myFirstObj.start
        },
        Future {
            mySecondObj.initialState
        }
        ))
        Await.result(result, 20.second)
    }
    run
}

输出：

Exception in thread "main" java.util.concurrent.TimeoutException: Future timed out after [20 seconds]
    at scala.concurrent.impl.Promise$DefaultPromise.tryAwait0(Promise.scala:248)
    at scala.concurrent.impl.Promise$DefaultPromise.result(Promise.scala:261)
    at scala.concurrent.Await$.$anonfun$result$1(package.scala:201)
    at scala.concurrent.BlockContext$DefaultBlockContext$.blockOn(BlockContext.scala:62)
    at scala.concurrent.Await$.result(package.scala:124)
    at workspace$.run(workspace.scala:23)
    at workspace$.delayedEndpoint$workspace$1(workspace.scala:25)
    at workspace$delayedInit$body.apply(workspace.scala:14)
    at scala.Function0.apply$mcV$sp(Function0.scala:39)
    at scala.Function0.apply$mcV$sp$(Function0.scala:39)
    at scala.runtime.AbstractFunction0.apply$mcV$sp(AbstractFunction0.scala:17)
    at scala.App.$anonfun$main$1(App.scala:76)
    at scala.App.$anonfun$main$1$adapted(App.scala:76)
    at scala.collection.IterableOnceOps.foreach(IterableOnce.scala:563)
    at scala.collection.IterableOnceOps.foreach$(IterableOnce.scala:561)
    at scala.collection.AbstractIterable.foreach(Iterable.scala:926)
    at scala.App.main(App.scala:76)
    at scala.App.main$(App.scala:74)
    at workspace$.main(workspace.scala:14)
    at workspace.main(workspace.scala)

我们可以看到我们在这里得到了一个超时异常。Future 初始化 myFirstObj，FirstObj 的实例在内部尝试初始化 SecondObj。

此外，下一步的 Future 尝试初始化 mySecondObj。这会导致潜在的死锁情况。

此外，程序的空间复杂度可能会增加，因为我们可能必须存储/缓存大量表达式。由于程序员无法控制程序的执行，因此调试在这里可能会变得很棘手。