lazy

13年前

Lazy initialization

From Wikipedia, the free encyclopedia

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 object is summoned, the flag is tested. If it is ready, it is returned. If not, it is initialized on the spot.

See lazy evaluation for a general treatment of this idea. In heavily imperative languages this pattern carries hidden dangers, as does any programming habit that relies on shared state.

Contents

 [hide]

[edit]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 (Multiton pattern, similar to the singleton pattern)
  • using lazy initialization to instantiate the object the first time it is requested (lazy initialization pattern).

[edit]Examples

[edit]C#

In .NET 4.0 Microsoft has included a Lazy class which can be used to do lazy loading. Below is a dummy code which does lazy loading of Class Fruit

Lazy<Fruit> lazyFruit = new Lazy<Fruit>();  Fruit fruit = lazyFruit.Value;  


Here is a dummy example in C#.

The Fruit class itself doesn't do anything here, The class variable _typesDictionary is a Dictionary/Map used to store Fruit instances by typeName.

using System;  using System.Collections;  using System.Collections.Generic;     public class Fruit {      private string _typeName;      private static Dictionary<string, Fruit> _typesDictionary = new Dictionary<string, Fruit>();         private Fruit(String typeName) {          this._typeName = typeName;      }         public static Fruit GetFruitByTypeName(string type) {          Fruit fruit;             if (!_typesDictionary.TryGetValue(type, out fruit)) {              // Lazy initialization              fruit = new Fruit(type);                 _typesDictionary.Add(type, fruit);          }          return fruit;      }         public static void ShowAll() {          if (_typesDictionary.Count > 0) {              Console.WriteLine("Number of instances made = {0}", _typesDictionary.Count);                 foreach (KeyValuePair<string, Fruit> kvp in _typesDictionary) {                  Console.WriteLine(kvp.Key);              }                 Console.WriteLine();          }      }  }     class Program {      static void Main(string[] args) {          Fruit.GetFruitByTypeName("Banana");          Fruit.ShowAll();             Fruit.GetFruitByTypeName("Apple");          Fruit.ShowAll();             // returns pre-existing instance from first           // time Fruit with "Banana" was created          Fruit.GetFruitByTypeName("Banana");          Fruit.ShowAll();             Console.ReadLine();      }  }  

[edit]Java

Here is an example in Java.

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) {          if (!types.containsKey(type)) {              types.put(type, new Fruit(type)); // Lazy initialization          }          return types.get(type);      }  }  

[edit]JavaScript

Here is an example in JavaScript.

var Fruit = (function() {    var types = {};    function Fruit() {};       // count own properties in object    function count(obj) {      var i = 0;      for (var key in obj) {        if (obj.hasOwnProperty(key)) {          ++i;        }      }      return i;    }       var _static = {      getFruit: function(type) {        if (typeof types[type] == 'undefined') {          types[type] = new Fruit;        }        return types[type];      },      printCurrentTypes: function () {        console.log('Number of instances made: ' + count(types));        for (var type in types) {          console.log(type);        }      }    };       return _static;     })();     Fruit.getFruit('Apple');  Fruit.printCurrentTypes();  Fruit.getFruit('Banana');  Fruit.printCurrentTypes();  Fruit.getFruit('Apple');  Fruit.printCurrentTypes();  

Output

Number of instances made: 1  Apple    Number of instances made: 2  Apple  Banana    Number of instances made: 2  Apple  Banana  

[edit]C++

Here is an example in C++.

#include <iostream>  #include <string>  #include <map>     using namespace std;     class Fruit {      public:          static Fruit* getFruit(const string& type);          static void printCurrentTypes();         private:          static map<string,Fruit*> types;          string type;             // note: constructor private forcing one to use static getFruit()          Fruit(const string& t) : type( t ) {}  };     //definition needed for using any static member variable  map<string,Fruit*> Fruit::types;             /*   * Lazy Factory method, gets the Fruit instance associated with a   * certain type. Instantiates new ones as needed.   * precondition: type. Any string that describes a fruit type, e.g. "apple"   * postcondition: The Fruit instance associated with that type.   */  Fruit* Fruit::getFruit(const string& type) {      map<string,Fruit*>::iterator it = types.find(type);  // try to find an existing instance; if not found std::map will return types.end()         Fruit *f;      if (it == types.end()) { // if no instance with the proper type was found, make one          f = new Fruit(type); // lazy initialization part          types[type] = f;     // adding the newly created Fruit to the types map for later lookup      } else { //if already had an instance          f = it->second; //The return value will be the found fruit      }      return f;  }     /*   * For example purposes to see pattern in action   */  void Fruit::printCurrentTypes() {      if (!types.empty()) {          cout << "Number of instances made = " << types.size() << endl;          for (map<string,Fruit*>::iterator iter = types.begin(); iter != types.end(); ++iter) {              cout << (*iter).first << endl;          }          cout << endl;      }  }     int main(void) {      Fruit::getFruit("Banana");      Fruit::printCurrentTypes();         Fruit::getFruit("Apple");      Fruit::printCurrentTypes();         // returns pre-existing instance from first       // time Fruit with "Banana" was created      Fruit::getFruit("Banana");      Fruit::printCurrentTypes();         return 0;  }     /*  OUTPUT:  Number of instances made = 1  Banana     Number of instances made = 2  Apple  Banana     Number of instances made = 2  Apple  Banana  */  

[edit]Smalltalk

Here is an example in Smalltalk, of a typical accessor method to return the value of a variable using lazy initialization.

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

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.

    initialize          height := 2.0         height          ^height  

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

[edit]Ruby

Here is an example in Ruby, of lazily initializing an authentication token from a remote service like Google. The way that @auth_token is cached is also an example of memoization.

require 'net/http'  class Blogger    def auth_token      @auth_token ||=        (res = Net::HTTP.post_form(uri, params)) &&        get_token_from_http_response(res)    end       # get_token_from_http_response, uri and params are defined later in the class  end     b = Blogger.new  b.instance_variable_get(:@auth_token) # returns nil  b.auth_token # returns token  b.instance_variable_get(:@auth_token) # returns token  

[edit]Python

Here is an example in Python.

class Fruit:      def __init__(self, sort):          self.sort = sort     class Fruits:      def __init__(self):          self.sorts = {}         def get_fruit(self, sort):          if sort not in self.sorts:              self.sorts[sort] = Fruit(sort)             return self.sorts[sort]     if __name__ == '__main__':      fruits = Fruits()      print fruits.get_fruit('Apple')      print fruits.get_fruit('Lime')  

[edit]PHP

Here is an example of lazy initialization in PHP 5:

<?php  header('Content-type:text/plain; charset=utf-8');     class Fruit {      private $type;      private static $types = array();         private function __construct($type) {          $this->type = $type;      }         public static function getFruit($type) {          // Lazy initialization takes place here          if (!array_key_exists($type, self::$types)) {              self::$types[$type] = new Fruit($type);          }             return self::$types[$type];      }         public static function printCurrentTypes() {          echo 'Number of instances made: ' . count(self::$types) . "\n";          foreach (array_keys(self::$types) as $key) {              echo "$key\n";          }          echo "\n";      }  }     Fruit::getFruit('Apple');  Fruit::printCurrentTypes();     Fruit::getFruit('Banana');  Fruit::printCurrentTypes();     Fruit::getFruit('Apple');  Fruit::printCurrentTypes();     /*  OUTPUT:     Number of instances made: 1  Apple     Number of instances made: 2  Apple  Banana     Number of instances made: 2  Apple  Banana  */