What's the (hidden) cost of Scala's lazy val?

Question

One handy feature of Scala is lazy val, where the evaluation of a val is delayed until it's necessary (at first access).

Of course, a lazy val must have some overhead - somewhere Scala must keep track of whether the value has already been evaluated and the evaluation must be synchronized, because multiple threads might try to access the value for the first time at the same time.

What exactly is the cost of a lazy val - is there a hidden boolean flag associated with a lazy val to keep track if it has been evaluated or not, what exactly is synchronized and are there any more costs?

In addition, suppose I do this:

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

Is this the same as having two separate lazy vals x and y or do I get the overhead only once, for the pair (x, y)?

Answer 1

This is taken from the scala mailing list and gives implementation details of lazy in terms of Java code (rather than bytecode):

class LazyTest {   lazy val msg = "Lazy" } 

is compiled to something equivalent to the following Java code:

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;   }  }