Lazy initialization

Nella programmazione software, si dice Lazy initialization (inizializzazione pigra) la tattica di instanziare un oggetto, inizializzare una variabile, effettuare un calcolo o un eseguire un processo solo nel momento in cui tale operazione è richiesta. Tipico esempio è il flag indicante l'avvenimento di un determinato processo. Ogni volta che avviene un certo evento, si esamina il flag. Se questo è abbassato, si continua, altrimenti si inizializza una certa variabile o si instanzia un certo oggetto.

La "lazy factory"

Dal punto di vista dei software design pattern, la lazy initialization si usa spesso con un factory method pattern. Questo combina tre idee:

• usare un factory method per instanziare una classe (factory method pattern);
• memorizzare l'istanza di una mappa, in modo tale da poter riprendere la stessa istanza la volta successiva che si richiede la stessa con certi parametri (confronta con un singleton pattern);
• usare la lazy initialization per istanziare un oggetto la prima volta che è richiesto (lazy initialization pattern).

Un piccolo esempio (in Java). La classe Fruit non fa' nulla qui, questo è solo un esempio per mostrare l'architettura. La variabile types è una mappa useta per memorizzare le istanze di Fruit per tipo.

import java.util.*;

public class Fruit {
    private static Map types = new HashMap(); 
    private String type;      

    // using a private constructor to force use of the factory method.
    private Fruit(String type){
        this.type=type;
        types.put(type, this);
    }

    /**
     * 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 Fruit getFruit(String type){
        Fruit f;
        if (types.containsKey(type)){
            f = (Fruit) types.get(type); // get the instance for that type   
        } else {
            f = new Fruit(type); // lazy initialization
        }
        return f;
    }
}

La tecnica può essere usata anche in un linguaggio non-object-oriented.