Co to jest leniwa inicjalizacja i dlaczego jest przydatna?


83

Co to jest leniwa inicjalizacja obiektów? Jak to robisz i jakie są zalety?

Odpowiedzi:


105

Inicjalizacja z opóźnieniem to optymalizacja wydajności, w której odraczasz (potencjalnie kosztowne) tworzenie obiektów do momentu, gdy faktycznie ich potrzebujesz.

Dobrym przykładem jest to, aby nie tworzyć połączenia z bazą danych z góry, ale tylko tuż przed uzyskaniem danych z bazy danych.

Głównym powodem tego jest to, że (często) można całkowicie uniknąć tworzenia obiektu, jeśli nigdy go nie potrzebujesz.


39
Powinno to być oczywiste, ale na wszelki wypadek, gdyby to przeoczył: powodem, dla którego jest to optymalizacja, jest to, że często okazuje się, że nie musisz w ogóle tworzyć, i ponieważ możesz zaoszczędzić na pracy, gdy komputer jest już zajęty aż do czasu, kiedy jest mniej ruchliwy.
— Joel Coehoorn

Dobry komentarz. Poprawiłem odpowiedź, aby uwzględnić twój punkt widzenia.
— Bevan

bardzo dobry (i inny) przypadek użycia / powód użycia Lazyjest zamieszczony w następującym pytaniu SO: stackoverflow.com/a/15894928/4404962 ta sugestia rozwiązała dokładnie to, co musieliśmy rozwiązać - używając Lazyjako głównego podmiotu
— lev haikin

51

Jak wspominali inni, leniwa inicjalizacja opóźnia inicjalizację do momentu użycia składnika lub obiektu. Możesz postrzegać leniwą inicjalizację jako aplikację wykonawczą z zasadą YAGNI - „ You ain't gonna need it”

Zalety leniwej inicjalizacji z punktu widzenia aplikacji polegają na tym, że użytkownicy nie muszą płacić za czas inicjalizacji za funkcje, których nie będą używać. Załóżmy, że miałbyś zainicjować każdy komponent aplikacji z góry. Może to spowodować potencjalnie długi czas uruchamiania - użytkownicy musieliby czekać dziesiątki sekund lub minut, zanim aplikacja będzie gotowa do użycia. Czekają i płacą za inicjalizację funkcji, z których mogą nigdy nie korzystać lub których mogą nie używać od razu.

Zamiast tego, jeśli odroczysz inicjalizację tych komponentów do czasu ich użycia, aplikacja uruchomi się znacznie szybciej. Użytkownik nadal będzie musiał zapłacić koszt uruchomienia podczas korzystania z innych komponentów, ale ten koszt będzie amortyzowany przez cały przebieg programu i nie będzie skondensowany na początku, a użytkownik może powiązać czas inicjalizacji tych obiektów z funkcjami, którymi są za pomocą.


Szkoda, że ​​mogłem dać tylko +1! Przy okazji, dobre uzasadnienie.
— Rajendra Uppal

1
YAGNI oznacza „nie będziesz tego potrzebować [funkcja, kod]”. Inicjalizacja z opóźnieniem to optymalizacja, która jest funkcją samą w sobie. Powiedziałbym raczej, że ma to zastosowanie w drugą stronę: jeśli nie wiesz na pewno, że potrzebujesz leniwej inicjalizacji, nie używaj YAGNI.
— Flavius

19

Inicjalizacja z opóźnieniem to koncepcja odroczenia tworzenia obiektu do czasu jego pierwszego użycia. Jeśli jest używany prawidłowo, może spowodować znaczny wzrost wydajności.

Osobiście użyłem Lazy Initialization podczas tworzenia własnego, ręcznie zwijanego ORM w .NET 2.0. Podczas ładowania moich kolekcji z bazy danych rzeczywiste elementy kolekcji były inicjowane z opóźnieniem. Oznaczało to, że kolekcje powstawały szybko, ale każdy obiekt był ładowany tylko wtedy, gdy tego potrzebowałem.

Jeśli znasz wzorzec Singleton, prawdopodobnie widziałeś również leniwą inicjalizację w akcji.

public class SomeClassSingleton
{
    private static SomeClass _instance = null;

    private SomeClassSingleton()
    {
    }

    public static SomeClass GetInstance()
    {
        if(_instance == null)
            _instance = new SomeClassSingleton();

        return _instance;
    }
}

W takim przypadku wystąpienie SomeClass nie jest inicjowane, dopóki nie będzie wymagane przez konsumenta SomeClassSingleton.


Usuń jawne ustawienie zmiennej prywatnej na „null”, aby nieco poprawić szybkość;). W każdym razie jest to zbędne.
— nicodemus 13

fajna uwaga, SomeClassSingleton musi być równą lub niższą klasą SomeClass
— Fredrick Gauss

Nie wiem, czy ktoś czyta stare odpowiedzi, ale zakładam, że prywatna statyczna metoda instancji get powinna być publiczna?
— Biscuit128

@ Biscuit128 - czytam je i tak powinno być. Zaktualizowałem to na wypadek, gdyby ktoś jeszcze to czytał.
— Justin Niessner,

nie powinno _instance = new SomeClassSingleton (); be _instance = new SomeClass (); ? lub rozumiem z innej perspektywy
— ashishdhiman 2007

6

Ogólnie rzecz biorąc, „leniwa ocena” oznacza odraczanie przetwarzania czegoś do momentu, gdy faktycznie tego potrzebujesz. Główną ideą jest to, że czasami można uniknąć kosztownych operacji, jeśli okaże się, że ich nie potrzebujesz lub jeśli wartość zmieniłaby się, zanim z niej skorzystasz.

Prostym tego przykładem jest System.Exception.StackTrace. Jest to właściwość typu string w przypadku wyjątku, ale w rzeczywistości nie jest tworzona, dopóki nie uzyskasz do niej dostępu. Wewnętrznie robi coś takiego:

String StackTrace{
  get{
    if(_stackTrace==null){
      _stackTrace = buildStackTrace();
    }
    return _stackTrace;
  }
}

Oszczędza to narzutów związanych z faktycznym wywoływaniem buildStackTrace, dopóki ktoś nie będzie chciał zobaczyć, co to jest.

Właściwości są jednym ze sposobów na zapewnienie tego typu zachowania.


2
To prawda, ale i tak nie jestem pewien, dlaczego miałbyś udostępniać odniesienie do wyjątku w wielu wątkach.
— Dolphin

3

Tutaj możesz przeczytać o Lazy Initialization z przykładowym kodem.

  • Gdy masz obiekt, którego tworzenie jest drogie, a program może go nie używać. Na przykład załóżmy, że masz w pamięci obiekt Customer, który ma właściwość Orders zawierającą dużą tablicę obiektów Order, które do zainicjowania wymagają połączenia z bazą danych. Jeśli użytkownik nigdy nie prosi o wyświetlenie Zamówień lub użycie danych w obliczeniach, nie ma powodu, aby używać pamięci systemowej lub cykli obliczeniowych do ich tworzenia. Używając Lazy, aby zadeklarować obiekt Orders do opóźnionej inicjalizacji, można uniknąć marnowania zasobów systemowych, gdy obiekt nie jest używany.

  • Gdy masz obiekt, który jest drogi w tworzeniu i chcesz odłożyć jego utworzenie do czasu zakończenia innych kosztownych operacji. Na przykład załóżmy, że program ładuje kilka instancji obiektów podczas uruchamiania, ale tylko niektóre z nich są wymagane natychmiast. Wydajność uruchamiania programu można poprawić, odraczając inicjalizację obiektów, które nie są wymagane, do momentu utworzenia wymaganych obiektów.


3

Leniwa inicjalizacja obiektu oznacza, że ​​jego utworzenie jest odroczone do czasu jego pierwszego użycia. (W tym temacie terminy inicjowanie z opóźnieniem i instancje z opóźnieniem są synonimami). Inicjowanie z opóźnieniem jest używane głównie w celu zwiększenia wydajności, uniknięcia niepotrzebnych obliczeń i zmniejszenia wymagań dotyczących pamięci programu. Oto najczęstsze scenariusze:

Gdy masz obiekt, którego tworzenie jest drogie, a program może go nie używać. Na przykład załóżmy, że masz w pamięci obiekt Customer, który ma właściwość Orders zawierającą dużą tablicę obiektów Order, które do zainicjowania wymagają połączenia z bazą danych. Jeśli użytkownik nigdy nie prosi o wyświetlenie Zamówień lub użycie danych w obliczeniach, nie ma powodu, aby używać pamięci systemowej lub cykli obliczeniowych do ich tworzenia. Używając Lazy, aby zadeklarować obiekt Orders do opóźnionej inicjalizacji, można uniknąć marnowania zasobów systemowych, gdy obiekt nie jest używany.

Gdy masz obiekt, który jest drogi w tworzeniu i chcesz odłożyć jego utworzenie do czasu zakończenia innych kosztownych operacji. Na przykład załóżmy, że program ładuje kilka instancji obiektów podczas uruchamiania, ale tylko niektóre z nich są wymagane natychmiast. Wydajność uruchamiania programu można poprawić, odraczając inicjalizację obiektów, które nie są wymagane, do momentu utworzenia wymaganych obiektów.

Chociaż możesz napisać własny kod, aby wykonać leniwą inicjalizację, zalecamy zamiast tego użycie Lazy. Lazy i powiązane typy obsługują również bezpieczeństwo wątków i zapewniają spójne zasady propagacji wyjątków.


2
//Lazy instantiation delays certain tasks. 
//It typically improves the startup time of a C# application.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LazyLoad
{
    class Program
    {
        static void Main(string[] args)
        {
            Lazy<MyClass> MyLazyClass = new Lazy<MyClass>(); // create lazy class
            Console.WriteLine("IsValueCreated = {0}",MyLazyClass.IsValueCreated); // print value to check if initialization is over

            MyClass sample = MyLazyClass.Value; // real value Creation Time
            Console.WriteLine("Length = {0}", sample.Length); // print array length

            Console.WriteLine("IsValueCreated = {0}", MyLazyClass.IsValueCreated); // print value to check if initialization is over
            Console.ReadLine();
        }
    }

    class MyClass
    {
        int[] array;
        public MyClass()
        {
            array = new int[10];

        }

        public int Length
        {
            get
            {
                return this.array.Length;
            }
        }
    }
}


// out put

// IsValueCreated = False
// Length = 10
// IsValueCreated = True

1

Jak dotąd zrozumiałem o leniwym inicie, że program nie ładuje / nie żąda wszystkich danych raz. Czeka na jego użycie, zanim zażąda go np. serwer SQL.

Jeśli masz bazę danych z dużą tabelą połączoną z dużą liczbą podtabel i nie potrzebujesz szczegółów połączonych z innych tabel, chyba że przechodzisz do „edycji” lub „przeglądania szczegółów”, wtedy Lazy Init. pomoże aplikacji działać szybciej i najpierw "leniwie ładować" szczegółowe dane, gdy będą potrzebne.

W SQL lub LINQ możesz ustawić to „ustawienie” w modelu prod bazy danych. element danych.

Mam nadzieję, że to ma sens dla twojego pytania?

Klient sieciowy (np. Przeglądarka) robi to samo. Obrazy są „ładowane z opóźnieniem” po kodzie HTML, a AJAX jest również „rodzajem leniwego inicjalizacji”, jeśli jest używany prawidłowo.


1

Wspomniane do tej pory przykłady baz danych są dobre, ale nie ogranicza się to tylko do warstwy dostępu do danych. Możesz zastosować te same zasady w każdej sytuacji, w której wydajność lub pamięć mogą być problemem. Dobry przykład (choć nie .NET) znajduje się w kakao, gdzie możesz poczekać, aż użytkownik zażąda okna, aby załadować go (i powiązane z nim obiekty) z końcówki. Może to pomóc zmniejszyć zużycie pamięci i przyspieszyć początkowe ładowanie aplikacji, zwłaszcza gdy mówisz o takich rzeczach, jak okna Preferencji, które nie będą potrzebne do późniejszego czasu, jeśli w ogóle.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.