Czy jest jakiś powód, dla którego leniwa inicjalizacja nie mogła zostać wbudowana w Javę?

Ponieważ pracuję na serwerze bez absolutnie żadnego nietrwałego stanu dla użytkowników, każdy obiekt związany z użytkownikiem jest wdrażany przy każdym żądaniu.

W rezultacie często robię leniwe inicjowanie właściwości obiektów, które mogą pozostać nieużywane.

protected EventDispatcher dispatcher = new EventDispatcher();

Staje się...

protected EventDispatcher<EventMessage> dispatcher;

public EventDispatcher<EventMessage> getEventDispatcher() {
    if (dispatcher == null) {
        dispatcher = new EventDispatcher<EventMessage>();
    }
    return dispatcher;
}

Czy jest jakiś powód, dla którego nie można tego wbudować w Javę?

protected lazy EventDispatcher dispatcher = new EventDispatcher();

Jak wspomniano poniżej w komentarzach, zdaję sobie sprawę, że język może ewoluować teoretycznie i obejmować wszystko, co tylko chcesz. Szukam praktycznego pomiaru możliwości. Czy to koliduje z innymi funkcjami? Czy implementacja jest wystarczająco prosta, aby działała dobrze z istniejącą maszyną JVM? A nawet, czy to dobry pomysł?

Oto ośmiostronicowa odpowiedź na twoje pytanie: http://tinlizzie.org/~awarth/papers/fool07.pdf

Jeśli mogę spróbować z grubsza streścić problemy z dodawaniem lenistwa, to są to przypadki narożne. Istnieje wiele zastrzeżeń dotyczących efektów ubocznych. Zastanów się, w twoim przykładzie, czy konstruktor miał widoczne skutki uboczne, takie jak uderzenie w globalny licznik lub wykonywanie operacji we / wy ... Trudno jest zrozumieć, kiedy to się stanie. Lub rozważ jeszcze brzydsze skutki uboczne związane z wyjątkami (są rzucane ... kiedy odwołujesz się do leniwego obiektu?)

Wystarczy przejść do sekcji 6 powyższego artykułu. (I podziwiaj całą logikę formalną systemu pisma na stronach, które pomijasz ...)

Oczywiście jest to absolutnie możliwe. W rzeczywistości scala ma już dokładnie tę funkcję! (Scala jest językiem JVM i kompiluje się do kodu bajtowego). Oto fragment źródła Scala:

class Foo {
  lazy val bar = "Hello World"
}

A oto jak wygląda pośrednia postać skompilowanego kodu:

scalac -Xprint:icode Foo.scala

[[syntax trees at end of icode]]// Scala source: Foo.scala
package <empty> {
  class Foo extends java.lang.Object with ScalaObject {
    @volatile protected var bitmap$0: Int = 0;
    lazy private[this] var bar: java.lang.String = _;
    <stable> <accessor> lazy def bar(): java.lang.String = {
      if (Foo.this.bitmap$0.&(1).==(0))
        {
          Foo.this.synchronized({
            if (Foo.this.bitmap$0.&(1).==(0))
              {
                Foo.this.bar = "Hello World";
                Foo.this.bitmap$0 = Foo.this.bitmap$0.|(1);
                ()
              };
            scala.runtime.BoxedUnit.UNIT
          });
          ()
        };
      Foo.this.bar
    };
    def this(): Foo = {
      Foo.super.this();
      ()
    }
  }

}

Myślę, że najpierw musisz dodać prawdziwe właściwości do języka Java, zamiast polegać na idiomie getX / setX. W ten sposób możesz po prostu oznaczyć właściwość jako leniwą (i zsynchronizowaną, tylko do odczytu itp.).

Sortuj co jest proszony o tutaj (Objective-C, ale koncepcja dotyczy).

Oczywiście można to dodać do Javy, słowo kluczowe leniwe można zaimplementować jako cukier składniowy. Jednak to, czy zostanie ono wdrożone, zależy od wizji konstruktorów kompilatorów.