Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Since I'm working on a server with absolutely no non-persisted state for users, every User-related object we have is rolled out on every request.

Consequently I often find myself doing lazy initialization of properties of objects that may go unused.

protected EventDispatcher dispatcher = new EventDispatcher();


protected EventDispatcher<EventMessage> dispatcher;

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

Is there any reason this couldn't be built into Java?

protected lazy EventDispatcher dispatcher = new EventDispatcher();

As mentioned below in the comments, I realize a language could theoretically evolve to include most anything you want. I'm looking for a practical measurement of possibility. Would this conflict with other features? Is the implementation simple enough to work well with the JVM as it exists? And even, is it a good idea?

share|improve this question
dunno but example code isn't thread-safe – Alison Feb 19 '11 at 2:03
@Alison the synchronized keyword would work the same as if it was on the method. I imagine there would be some accomodation of more complicated construction methods. In my specific use case, due to the nature of the problem, with every request as it's own world, synchronized is pointless. – NickC Feb 19 '11 at 2:09
In C# Lazy is in a library, but it is supported by the language. Does Java have lambdas and delegates and closures? By the way, you do want to ask this on SO, so that Jon Skeet & co. can share their wisdom. – Job Feb 19 '11 at 4:25
You can build pretty much everything into any language. But complexity budget and feature list are limited and the language designers can only include what they consider most important (well, except Larry Wall - especially in Perl 6 aka "All your paradigms are belong to us."). – delnan Feb 19 '11 at 11:43
The fundamental problem is that Java is about the only statically typed language with no meta-programming facility. In C you could write this as a macro in ten minutes. In C++ you could write this as a template in about two minutes. In Java you can ... paste and modify. – kevin cline Sep 27 '11 at 7:29
up vote 14 down vote accepted

Here is an eight page answer to your question:

If i can try and coarsely summarize the problems with adding laziness, it's the corner cases. There are a lot of caveats around side-effects. Consider, in your example, if the constructor had visible side-effects like bumping a global counter or doing I/O... It's hard to reason about when that would happen. Or consider even uglier side-effects about exceptions (they're thrown ... when you reference the lazy object?)

Just skip to section 6 in the above paper. (And admire all the type system formal logic on the pages you skip ...)

share|improve this answer
Thanks for the pointer to Alessandro's paper! – Frank Shearar Sep 27 '11 at 7:38
Accepting this answer due to the depth that the paper addresses this feature. Thanks! – NickC Oct 3 '11 at 18:02

Of course it is eminently possible. In fact, scala already has exactly this feature! (Scala is a JVM language and compiles down to bytecode). Here is a piece of scala source:

class Foo {
  lazy val bar = "Hello World"

And here is what an intermediate form of the compiled code looks like:

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))
            if (Foo.this.bitmap$0.&(1).==(0))
       = "Hello World";
                Foo.this.bitmap$0 = Foo.this.bitmap$0.|(1);
    def this(): Foo = {


share|improve this answer
So how would this reconcile with P.T.'s answer at ? – Pacerier Jun 25 '14 at 4:38

I think you first need to add real properties to the Java langauge, rather than relying on the getX/setX idiom. That way you could just mark the property as lazy (and synchronized, readonly etc...).

Sort of what is asked for here (Objective-C, but concept applies).

share|improve this answer

Of course this could be added to Java, the keyword lazy could be implemented as syntactic sugar. However, wether it will be implemented depends on the vision of the compiler builders.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.