Osobiście nie spotkałem się z sytuacją, w której musiałem używać typu WeakReference w .Net, ale wydaje się, że popularne jest to, że powinno się go używać w pamięci podręcznej. Dr Jon Harrop w swojej odpowiedzi na to pytanie bardzo dobrze uzasadnił użycie WeakReferences w pamięci podręcznej .

Często słyszałem też, jak programiści AS3 mówią o używaniu słabych referencji, aby zaoszczędzić na pamięci, ale na podstawie przeprowadzonych rozmów wydaje się, że zwiększają złożoność, niekoniecznie osiągając zamierzony cel, a zachowanie w czasie wykonywania jest raczej nieprzewidywalne. Do tego stopnia, że ​​wielu po prostu się poddaje i zamiast tego ostrożniej zarządza zużyciem pamięci / optymalizuje kod, aby mniej obciążał pamięć (lub zmniejszał liczbę cykli procesora i zajmował mniej miejsca).

Dr Jon Harrop zwrócił także uwagę w swojej odpowiedzi, że słabe referencje .Net nie są miękkie, a na gen0 istnieje agresywny zbiór słabych referencji. Według MSDN długie słabe referencje dają możliwość odtworzenia obiektu but the state of the object remains unpredictable.!

Biorąc pod uwagę te cechy, nie mogę wymyślić sytuacji, w której przydatne byłyby słabe referencje, może ktoś mógłby mnie oświecić?

Znalazłem uzasadnione praktyczne zastosowania słabych referencji w następujących trzech rzeczywistych sytuacjach, które faktycznie mi się przydarzyły:

Aplikacja 1: Procedury obsługi zdarzeń

Jesteś przedsiębiorcą Twoja firma sprzedaje kontrolę iskierników dla WPF. Sprzedaż jest świetna, ale zabijają cię koszty wsparcia. Zbyt wielu klientów narzeka na zawieszenie procesora i wycieki pamięci, gdy przewijają ekrany pełne iskier. Problem polega na tym, że ich aplikacja tworzy nowe linie iskrowe, gdy pojawiają się w widoku, ale wiązanie danych zapobiega gromadzeniu śmieci przez stare. Co robisz?

Wprowadź słabe odniesienie między powiązaniem danych a formantem, aby samo powiązanie danych nie zapobiegało gromadzeniu elementów bezużytecznych. Następnie dodaj do swojej kontrolera finalizator, który zrywa powiązanie danych po ich zebraniu.

Aplikacja 2: Zmienne wykresy

Jesteś następnym Johnem Carmackiem. Wynalazłeś genialną, opartą na grafie reprezentację hierarchicznych powierzchni podziału, dzięki której gry Tima Sweeneya wyglądają jak Nintendo Wii. Oczywiście nie powiem ci dokładnie, jak to działa, ale wszystko koncentruje się na tym zmiennym wykresie, na którym można znaleźć sąsiadów wierzchołka Dictionary<Vertex, SortedSet<Vertex>>. Topologia wykresu zmienia się wraz z bieganiem gracza. Jest tylko jeden problem: twoja struktura danych zrzuca nieosiągalne subgrafy podczas działania i musisz je usunąć, inaczej wyciek pamięci. Na szczęście jesteś geniuszem, więc wiesz, że istnieje klasa algorytmów specjalnie zaprojektowanych do lokalizowania i gromadzenia nieosiągalnych subgrafów: śmieciarki! Przeczytałeś doskonałą monografię Richarda Jonesa na ten tematale wprawia Cię w zakłopotanie i niepokój o zbliżający się termin. Co robisz?

Po prostu zamieniając swój Dictionaryna słaby stół mieszający, możesz nałożyć na siebie istniejący GC i automatycznie zbierać dla ciebie nieosiągalne podgrupy! Powrót do przeglądania reklam Ferrari.

Aplikacja 3: Dekorowanie drzew

Zwisasz z sufitu cyklicznego pokoju przy klawiaturze. Masz 60 sekund na przeszukanie DUŻYCH DANYCH, zanim ktoś Cię znajdzie. Przyszedłeś przygotowany z pięknym parserem opartym na strumieniu, który polega na GC do zbierania fragmentów AST po ich przeanalizowaniu. Ale zdajesz sobie sprawę, że potrzebujesz dodatkowych metadanych na każdym AST Nodei potrzebujesz go szybko. Co robisz?

Możesz użyć a Dictionary<Node, Metadata>do powiązania metadanych z każdym węzłem, ale jeśli go nie wyczyścisz, silne odwołania ze słownika do starych węzłów AST utrzymają je przy życiu i spowodują wyciek pamięci. Rozwiązaniem jest słaba tablica skrótów, która utrzymuje tylko słabe odwołania do kluczy, a śmieci zbierają powiązania klucz-wartość, gdy klucz staje się nieosiągalny. Następnie, gdy węzły AST stają się nieosiągalne, są one odśmiecane, a ich powiązanie klucz-wartość jest usuwane ze słownika, pozostawiając odpowiednie metadane nieosiągalne, więc również zostaje zebrane. Następnie wszystko, co musisz zrobić po zakończeniu głównej pętli, to wślizgnąć się z powrotem przez otwór wentylacyjny, pamiętając o wymianie, gdy tylko pojawi się ochroniarz.

Zauważ, że we wszystkich trzech rzeczywistych aplikacjach, które mi się przydarzyły, chciałem, aby GC zbierała tak agresywnie, jak to możliwe. Dlatego są to legalne aplikacje. Wszyscy inni się mylą.

Biorąc pod uwagę te cechy, nie mogę wymyślić sytuacji, w której przydatne byłyby słabe referencje, może ktoś mógłby mnie oświecić?

Dokument Microsoft Słabe wzorce zdarzeń .

W aplikacjach możliwe jest, że procedury obsługi dołączone do źródeł zdarzeń nie zostaną zniszczone w koordynacji z obiektem detektora, który podłączył procedurę obsługi do źródła. Ta sytuacja może prowadzić do wycieków pamięci. Windows Presentation Foundation (WPF) wprowadza wzorzec projektowy, którego można użyć do rozwiązania tego problemu, zapewniając dedykowaną klasę menedżera dla poszczególnych zdarzeń i implementując interfejs dla detektorów dla tego zdarzenia. Ten wzorzec projektowy jest znany jako wzorzec słabych zdarzeń.

...

Wzorzec słabych zdarzeń ma na celu rozwiązanie tego problemu wycieku pamięci. Wzorzec słabego zdarzenia może być używany za każdym razem, gdy detektor musi zarejestrować się w celu uzyskania zdarzenia, ale detektor nie wie wyraźnie, kiedy się wyrejestrować. Wzorzec słabych zdarzeń może być również użyty, ilekroć czas życia obiektu źródła przekracza czas użytecznego obiektu nasłuchiwania. (W tym przypadku użyteczność jest określana przez Ciebie.) Wzorzec słabych zdarzeń pozwala słuchaczowi zarejestrować się i odebrać zdarzenie, nie wpływając w żaden sposób na charakterystykę czasu życia obiektu. W efekcie domniemane odwołanie ze źródła nie określa, czy detektor kwalifikuje się do odśmiecania. Odwołanie jest słabym odwołaniem, a zatem nazewnictwo wzorca słabych zdarzeń i powiązanych interfejsów API. Nasłuchiwanie może zostać wyrzucone na śmietnik lub w inny sposób zniszczone, a źródło może być kontynuowane bez zachowania niemożliwych do pobrania odniesień procedury obsługi do zniszczonego teraz obiektu.

Pozwól, że postawię to na pierwszym miejscu i wrócę do tego:

WeakReference jest przydatny, gdy chcesz mieć oko na obiekt, ale NIE chcesz, aby twoje obserwacje zapobiegały gromadzeniu tego obiektu

Zacznijmy od początku:

- przepraszam z góry za niezamierzone przestępstwo, ale wrócę na chwilę do poziomu „Dicka i Jane”, ponieważ nigdy nie można powiedzieć publiczności.

Więc kiedy masz obiekt X- określmy go jako instancję class Foo- NIE MOŻE on żyć sam (głównie prawda); W ten sam sposób, w jaki „Żaden człowiek nie jest wyspą”, istnieje tylko kilka sposobów, w jakie obiekt może awansować do Islandhood - chociaż nazywa się to korzeniem GC w CLR. Bycie rootem GC lub posiadanie ustalonego łańcucha połączeń / odniesień do roota GC jest w zasadzie tym, co decyduje o tym, czy Foo x = new Foo()śmieci są zbierane, czy nie .

Jeśli nie możesz wrócić do korzenia GC ani przez stertę, ani przez stos, jesteś skutecznie osierocony i prawdopodobnie zostaniesz oznaczony / zebrany w następnym cyklu.

W tym miejscu spójrzmy na kilka okropnie wymyślonych przykładów:

Po pierwsze Foo:

public class Foo 
{
    private static volatile int _ref = 0;
    public event EventHandler FooEvent;
    public Foo()
    {
        _ref++;
        Console.WriteLine("I am #{0}", _ref);
    }
    ~Foo()
    {
        Console.WriteLine("#{0} dying!", _ref--);
    }
}

Dość proste - nie jest bezpieczne dla wątków, więc nie próbuj tego, ale zachowuje przybliżoną „liczbę referencji” aktywnych instancji i dekrecji po ich sfinalizowaniu.

Teraz spójrzmy na FooConsumer:

public class NastySingleton
{
    // Static member status is one way to "get promoted" to a GC root...
    private static NastySingleton _instance = new NastySingleton();
    public static NastySingleton Instance { get { return _instance;} }

    // testing out "Hard references"
    private Dictionary<Foo, int> _counter = new Dictionary<Foo,int>();
    // testing out "Weak references"
    private Dictionary<WeakReference, int> _weakCounter = new Dictionary<WeakReference,int>();

    // Creates a strong link to Foo instance
    public void ListenToThisFoo(Foo foo)
    {
        _counter[foo] = 0;
        foo.FooEvent += (o, e) => _counter[foo]++;
    }

    // Creates a weak link to Foo instance
    public void ListenToThisFooWeakly(Foo foo)
    {
        WeakReference fooRef = new WeakReference(foo);
        _weakCounter[fooRef] = 0;
        foo.FooEvent += (o, e) => _weakCounter[fooRef]++;
    }

    private void HandleEvent(object sender, EventArgs args, Foo originalfoo)
    {
        Console.WriteLine("Derp");
    }
}

Mamy więc obiekt, który jest już własnym katalogiem głównym GC (cóż ... konkretnie, zostanie zrootowany przez łańcuch bezpośrednio do domeny aplikacji, w której działa ta aplikacja, ale to inny temat), który ma dwie metody zaczepienia się na Fooinstancji - przetestujmy to:

// Our foo
var f = new Foo();

// Create a "hard reference"
NastySingleton.Instance.ListenToThisFoo(f);

// Ok, we're done with this foo
f = null;

// Force collection of all orphaned objects
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

Czy w związku z powyższym spodziewałbyś się, że obiekt, o którym kiedyś była mowa, fbędzie „kolekcjonerski”?

Nie, ponieważ istnieje inny obiekt, który teraz zawiera odniesienie do niego - Dictionaryw tej Singletoninstancji statycznej.

Ok, spróbujmy słabego podejścia:

f = new Foo();
NastySingleton.Instance.ListenToThisFooWeakly(f);

// Ok, we're done with this foo
f = null;

// Force collection of all orphaned objects
// This should collect # 2 - you'll see a "#2 dying"
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

Teraz, kiedy mamy walnięcie nasze odniesienie do dokonywanych poza rynkiem Foo-to-było-raz w miesiącu f, nie nie są bardziej „twarde” odniesienia do obiektu, więc jest to dla kolekcjonerów - w WeakReferencestworzony przez słabego słuchacza nie będzie temu zapobiec.

Dobre przypadki użycia:

• Procedury obsługi zdarzeń (chociaż najpierw przeczytaj: Słabe zdarzenia w C # )

• Masz sytuację, w której spowodowałbyś „odwołanie rekurencyjne” (tj. Obiekt A odnosi się do obiektu B, który odnosi się do obiektu A, zwanego również „przeciekiem pamięci”) (edytuj: derp, oczywiście, że to nie jest to prawda)

• Chcesz „nadawać” coś do zbioru obiektów, ale nie chcesz być tym, co utrzymuje je przy życiu; a List<WeakReference>można łatwo utrzymać, a nawet przyciąć, usuwając gdzieref.Target == null

Jak logiczne wycieki, które są naprawdę trudne do wyśledzenia, podczas gdy użytkownicy po prostu zauważają, że uruchamianie oprogramowania przez długi czas ma tendencję do zajmowania coraz większej ilości pamięci i spowalniania aż do ponownego uruchomienia? Ja nie.

Zastanów się, co się stanie, jeśli użytkownik, który zażąda usunięcia zasobu aplikacji powyżej, Thing2nie poradzi sobie odpowiednio z takim zdarzeniem w ramach:

1. Wskaźniki
2. Mocne referencje
3. Słabe referencje

... i pod którym jednym z takich błędów prawdopodobnie zostanie złapany podczas testowania, a który nie i nie poleciałby pod radarem jak błąd myśliwca ukrycia. Współwłasność jest najczęściej bezsensownym pomysłem.

Bardzo ilustrującym przykładem słabych odniesień zastosowanych z dobrym skutkiem jest ConditionalWeakTable , która jest używana przez DLR (między innymi) do dołączania dodatkowych „elementów” do obiektów.

Nie chcesz, aby stół utrzymywał obiekt przy życiu. Ta koncepcja po prostu nie mogłaby działać bez słabych referencji.

Wydaje mi się jednak, że wszystkie zastosowania słabych referencji pojawiły się długo po ich dodaniu do języka, ponieważ słabe referencje są częścią .NET od wersji 1.1. Wygląda na to, że chciałbyś coś dodać, aby brak deterministycznego zniszczenia nie cofnął cię w kąt, jeśli chodzi o funkcje językowe.

Jeśli masz warstwę pamięci podręcznej zaimplementowaną w języku C #, znacznie lepiej jest umieścić dane w pamięci podręcznej jako słabe odwołania, może to pomóc w poprawie wydajności warstwy pamięci podręcznej.

Pomyśl, że to podejście można również zastosować do implementacji sesji. Ponieważ sesja jest przez długi czas przedmiotem życia, może to być przypadek, gdy nie ma pamięci dla nowego użytkownika. W takim przypadku znacznie lepiej będzie usunąć jakiś obiekt sesji użytkownika, a następnie zgłosić wyjątek OutOfMemoryException.

Ponadto, jeśli masz duży obiekt w aplikacji (jakaś duża tabela odnośników itp.), Należy go używać dość rzadko, a odtworzenie takiego obiektu nie jest bardzo kosztowną procedurą. Więc lepiej, aby to było jak tydzień odniesienia, aby mieć sposób na uwolnienie pamięci, gdy naprawdę tego potrzebujesz.