Какова (скрытая) стоимость ленивого Вэл Скала?
Одна удобная особенность Scala - lazy valгде оценка val задерживается, пока это не необходимо (при первом доступе).
Конечно, lazy val должны иметь некоторые издержки - где-то Scala должен отслеживать, было ли значение уже оценено, и оценка должна быть синхронизирована, потому что несколько потоков могут пытаться получить доступ к значению в первый раз одновременно.
Что именно стоит lazy val - есть ли скрытый логический флаг, связанный с lazy val чтобы отслеживать, была ли она оценена или нет, что именно синхронизировано и есть ли дополнительные расходы?
Кроме того, предположим, что я делаю это:
class Something {
lazy val (x, y) = { ... }
}
Это то же самое, что иметь два отдельных lazy vals x а также y или я получаю накладные расходы только один раз, для пары (x, y)?
6 ответов
Это взято из списка рассылки scala и дает подробности реализации lazy с точки зрения Java-кода (а не байт-кода):
class LazyTest {
lazy val msg = "Lazy"
}
компилируется во что-то, эквивалентное следующему коду Java:
class LazyTest {
public int bitmap$0;
private String msg;
public String msg() {
if ((bitmap$0 & 1) == 0) {
synchronized (this) {
if ((bitmap$0 & 1) == 0) {
synchronized (this) {
msg = "Lazy";
}
}
bitmap$0 = bitmap$0 | 1;
}
}
return msg;
}
}
Похоже, что компилятор организует поле int для битовой карты на уровне класса, чтобы пометить несколько ленивых полей как инициализированные (или нет), и инициализирует целевое поле в синхронизированном блоке, если соответствующий xor битовой карты указывает на необходимость.
С помощью:
class Something {
lazy val foo = getFoo
def getFoo = "foo!"
}
создает образец байт-кода:
0 aload_0 [this]
1 getfield blevins.example.Something.bitmap$0 : int [15]
4 iconst_1
5 iand
6 iconst_0
7 if_icmpne 48
10 aload_0 [this]
11 dup
12 astore_1
13 monitorenter
14 aload_0 [this]
15 getfield blevins.example.Something.bitmap$0 : int [15]
18 iconst_1
19 iand
20 iconst_0
21 if_icmpne 42
24 aload_0 [this]
25 aload_0 [this]
26 invokevirtual blevins.example.Something.getFoo() : java.lang.String [18]
29 putfield blevins.example.Something.foo : java.lang.String [20]
32 aload_0 [this]
33 aload_0 [this]
34 getfield blevins.example.Something.bitmap$0 : int [15]
37 iconst_1
38 ior
39 putfield blevins.example.Something.bitmap$0 : int [15]
42 getstatic scala.runtime.BoxedUnit.UNIT : scala.runtime.BoxedUnit [26]
45 pop
46 aload_1
47 monitorexit
48 aload_0 [this]
49 getfield blevins.example.Something.foo : java.lang.String [20]
52 areturn
53 aload_1
54 monitorexit
55 athrow
Значения, инициализированные в кортежах типа lazy val (x,y) = { ... } иметь вложенное кэширование через тот же механизм. Результат кортежа лениво оценивается и кэшируется, и доступ к x или y инициирует оценку кортежа. Извлечение индивидуального значения из кортежа выполняется независимо и лениво (и кэшируется). Таким образом, приведенный выше код двойной реализации генерирует x, yи x$1 поле типа Tuple2,
В Scala 2.10 ленивое значение, например:
class Example {
lazy val x = "Value";
}
скомпилирован в байтовый код, который похож на следующий код Java:
public class Example {
private String x;
private volatile boolean bitmap$0;
public String x() {
if(this.bitmap$0 == true) {
return this.x;
} else {
return x$lzycompute();
}
}
private String x$lzycompute() {
synchronized(this) {
if(this.bitmap$0 != true) {
this.x = "Value";
this.bitmap$0 = true;
}
return this.x;
}
}
}
Обратите внимание, что растровое изображение представлено boolean, Если вы добавите другое поле, компилятор увеличит размер поля, чтобы иметь возможность представлять как минимум 2 значения, т.е. byte, Это просто продолжается для огромных классов.
Но вы можете спросить, почему это работает? Кэши локального потока должны быть очищены при входе в синхронизированный блок, чтобы энергонезависимый x значение сбрасывается в память. Эта статья в блоге дает объяснение.
Я написал сообщение по этому вопросу https://dzone.com/articles/cost-laziness
В двух словах, штраф настолько мал, что на практике вы можете его игнорировать.
Scala SIP-20 предлагает новую реализацию lazy val, которая является более правильной, но на 25% медленнее, чем "текущая" версия.
Предлагаемая реализация выглядит так:
class LazyCellBase { // in a Java file - we need a public bitmap_0
public static AtomicIntegerFieldUpdater<LazyCellBase> arfu_0 =
AtomicIntegerFieldUpdater.newUpdater(LazyCellBase.class, "bitmap_0");
public volatile int bitmap_0 = 0;
}
final class LazyCell extends LazyCellBase {
import LazyCellBase._
var value_0: Int = _
@tailrec final def value(): Int = (arfu_0.get(this): @switch) match {
case 0 =>
if (arfu_0.compareAndSet(this, 0, 1)) {
val result = 0
value_0 = result
@tailrec def complete(): Unit = (arfu_0.get(this): @switch) match {
case 1 =>
if (!arfu_0.compareAndSet(this, 1, 3)) complete()
case 2 =>
if (arfu_0.compareAndSet(this, 2, 3)) {
synchronized { notifyAll() }
} else complete()
}
complete()
result
} else value()
case 1 =>
arfu_0.compareAndSet(this, 1, 2)
synchronized {
while (arfu_0.get(this) != 3) wait()
}
value_0
case 2 =>
synchronized {
while (arfu_0.get(this) != 3) wait()
}
value_0
case 3 => value_0
}
}
По состоянию на июнь 2013 года этот SIP не был одобрен. Я ожидаю, что он, вероятно, будет одобрен и включен в будущую версию Scala на основе обсуждения в списке рассылки. Следовательно, я думаю, что вы будете мудры, если прислушаетесь к замечаниям Дэниела Спевака:
Ленивый вал * не * бесплатен (или даже дешев). Используйте его, только если вам абсолютно необходима лень для корректности, а не для оптимизации.
Учитывая код, созданный scala для lazy, он может столкнуться с проблемой безопасности потоков, как упомянуто в двойной проверке блокировки http://www.javaworld.com/javaworld/jw-05-2001/jw-0525-double.html?page=1