lazy initialization

In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed.

This is typically accomplished by maintaining a flag indicating whether the process has taken place. Each time the desired thing is summoned, the flag is tested. If it is ready, it is returned. If not, it is initialized on the spot.

The "lazy factory"

In a software design pattern view, lazy initialization is often used together with a factory method pattern. This combines three ideas:

• using a factory method to get instances of a class (factory method pattern)
• storing the instances in a map, so you get the same instance the next time you ask for an instance with same parameter (compare with a singleton pattern)
• using lazy initialization to instantiate the object the first time it is requested (lazy initialization pattern).

Here is a dummy example (in Java). The Fruit class itself doesn't do anything here, this is just an example to show the architecture. The class variable types is a map used to store Fruit instances by type.

<source lang=java> import java.util.*;

public class Fruit {

   private static final Map<String,Fruit>types = new HashMap<String,Fruit>();
   private final String type;
 
   // using a private constructor to force use of the factory method.
   private Fruit(String type) {
     this.type = type;
   }
   
   /**
    * Lazy Factory method, gets the Fruit instance associated with a
    * certain type. Instantiates new ones as needed.
    * @param type Any string that describes a fruit type, e.g. "apple"
    * @return The Fruit instance associated with that type.
    */
   public static synchronized Fruit getFruit(String type) {
     Fruit f = types.get(type); // get the instance for that type
 
     if (f == null) {
       f = new Fruit(type); // lazy initialization
       types.put(type,f);
     }
 
     return f;
   }

} </source>

The following is an example (in Smalltalk) of a typical accessor method to return the value of a variable using lazy initialization.

<source lang=smalltalk>

   height
       height ifNil: [height := 2.0].
       ^height

</source> The 'non-lazy' alternative is to use an initialization method that is run when the object is created and then use a simpler accessor method to fetch the value.

<source lang=smalltalk>

   initialize
       height := 2.0

   height
       ^height

</source>

Note that lazy initialization can also be used in non-object-oriented languages.

See also

Proxy pattern

External links

• Article "Java Tip 67: Lazy instantiation - Balancing performance and resource usage" by Philip Bishop and Nigel Warren
• Java code examples
• Use Lazy Initialization to Conserve Resources
• Description from the Portland Pattern Repository
• Lazy Initialization of Application Server Services
• Lazy Inheritance in JavaScript

Donate to Wikimedia