Scala: valeurs paresseux pénalité de performance? Threadsafe? [dupliquer]

Question

  

Possible en double:    Quel est le coût (caché) de val paresseux? (Scala)

Scala permet de définir des valeurs paresseux

lazy val maybeUnusedValue = someCostlyInitialization

où someCostlyInitialization est évaluée uniquement sur la première utilisation de maybeUnusedValue. Autrement dit, il est évalué au plus une fois, et si maybeUnusedValue est jamais utilisé, il est également jamais évalué du tout.

Est-ce threadsafe? Quelles sont les implications de cette performance? Si cela doit être threadsafe, il doit utiliser une sorte de syncronization / utiliser Java volatile d'une certaine façon. Malheureusement, la spécification du langage Scala ne dit rien à ce sujet.

Answer 1

Il est fait thread-safe en utilisant revérifié verrouillage http://code-o-matic.blogspot.com/2009/05/double-checked-locking-idiom-sweet-in.html Il est évident que cela ne signifie que l'accès à vals paresseux est plus lent que les non-paresseux.

Answer 2

MISE À JOUR: OOPS, comme Vasil a souligné, la question est une copie d'un autre fil, et comme il arrive, il en est de cette réponse.

Je pris cette classe:

class Foo {
  lazy val test = "hi"
}

compilé et décompilé (avec jd-gui):

public class Foo
  implements ScalaObject
{
  private String test;
  public volatile int bitmap$0;

  public String test()
  {
    if (
      (this.bitmap$0 & 0x1) == 0);
    synchronized (this)
    {
      if (
        (this.bitmap$0 & 0x1) == 0) {
        this.test = "hi"; this.bitmap$0 |= 1; } return this.test;
    }
  }
}

Comme vous pouvez le voir utilise la double paradigme de contrôle avec une variable volatile. Je pense donc qu'il est sûr