Какова (скрытая) стоимость ленивого Вэл Скала?

Question

Одна удобная функция Scala - lazy val, где оценка val откладывается до тех пор, пока она не будет необходима (при первом доступе).

Конечно, lazy val должна иметь некоторые издержкигде-то Scala должен отслеживать, было ли значение уже оценено, и оценка должна быть синхронизирована, потому что несколько потоков могут попытаться получить доступ к значению в первый раз одновременно.

Какова точно стоимостьlazy val - существует ли скрытый логический флаг, связанный с lazy val для отслеживания того, был ли он оценен или нет, что именно синхронизируется и есть ли дополнительные расходы?

Кроме того, предположим, что ясделать это:

class Something {
    lazy val (x, y) = { ... }
}

Это то же самое, что иметь два отдельных lazy val s x и y или получить накладные расходы только один раз для пары (x, y)?

Answer 1

Он взят из списка рассылки 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;
  }

}

Answer 2

Похоже, что компилятор организует поле 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.

Answer 3

В 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 сбрасывалось в память. Эта статья блога дает объяснение .

Answer 4

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 на основе обсуждения в списке рассылки. Следовательно, я думаю, вы бы послушались наблюдения Даниэля Спевака :

Ленивый вал * не * бесплатен (или даже дешев). Используйте это только если вы абсолютно нужна лень для корректности, а не для оптимизации.

Answer 5

Я написал сообщение по этому вопросу https://dzone.com/articles/cost-laziness

В двух словах, штраф настолько мал, что на практике вы можете его игнорировать.

Answer 6

учитывая код, сгенерированный scala для lazy, он может столкнуться с проблемой безопасности потока, как упомянуто в двойной проверке блокировки http://www.javaworld.com/javaworld/jw-05-2001/jw-0525-double.html?page=1