C # 'da Çöp Toplamaya Zorlamak İçin En İyi Uygulama

Tecrübelerime göre, çoğu insan size çöp toplamaya zorlamanın akıllıca olmadığını söyleyecektir, ancak 0 neslinde her zaman toplanmayan ancak belleğin bir sorun olduğu bazı durumlarda büyük nesnelerle çalışıyorsanız, tahsilatı zorlamak uygun mu? Bunu yapmak için bir en iyi uygulama var mı?

En iyi uygulama, çöp toplamayı zorlamamaktır.

MSDN'ye göre:

"Collect'i çağırarak çöp toplamayı zorlamak mümkündür, ancak çoğu zaman bundan kaçınılmalıdır çünkü performans sorunları yaratabilir."

Ancak, Collect () çağrısının olumsuz bir etkisi olmayacağını doğrulamak için kodunuzu güvenilir bir şekilde test edebilirseniz, devam edin ...

Artık ihtiyacınız kalmadığında nesnelerin temizlendiğinden emin olmaya çalışın. Özel nesneleriniz varsa, "using deyimi" ve IDisposable arabirimini kullanmaya bakın.

Bu bağlantı, hafızayı boşaltma / çöp toplama vb. İle ilgili bazı iyi pratik tavsiyelere sahiptir:

http://msdn.microsoft.com/en-us/library/66x5fx1b.aspx

Şöyle bir bakın - çöp tenekesi% 10'dayken mutfak çöpünü atmak mı yoksa çıkarmadan önce doldurmasını sağlamak mı daha verimli?

Dolmasına izin vermeyerek, dışarıdaki çöp kutusuna gidip gelirken zamanınızı boşa harcarsınız. Bu, GC iş parçacığı çalıştığında olana benzer - tüm yönetilen iş parçacıkları çalışırken askıya alınır. Ve yanılmıyorsam, GC iş parçacığı birden fazla AppDomains arasında paylaşılabilir, bu nedenle çöp toplama hepsini etkiler.

Elbette yakın zamanda çöp tenekesine hiçbir şey eklemeyeceğiniz bir durumla karşılaşabilirsiniz - mesela, tatile çıkacaksanız. O halde dışarı çıkmadan önce çöpü atmak iyi bir fikir olacaktır.

Bu, bir GC'yi zorlamanın yardımcı olabileceği bir kez OLABİLİR - programınız boşta kalırsa, kullanımdaki bellek çöp olarak toplanmaz çünkü ayırma yoktur.

En iyi uygulama, çoğu durumda çöp toplamayı zorlamamaktır. (Üzerinde çalıştığım her sistem çöp toplamaya zorladı, çözülürse çöp toplamayı zorlama ihtiyacını ortadan kaldıracak ve sistemi büyük ölçüde hızlandıracak sorunların altını çizen her sistem.)

Bir var birkaç durum size daha sonra çöp toplayıcı yapar bellek kullanımı hakkında daha fazla bilgi. Bu, çok kullanıcılı bir uygulamada veya bir seferde birden fazla isteğe yanıt veren bir hizmette olası değildir.

Bununla birlikte, bazı parti tipi işlemelerde , GC'den daha fazlasını bilirsiniz. Örneğin bir uygulama düşünün.

• Komut satırında dosya adlarının bir listesi verilir
• Tek bir dosyayı işler ve ardından sonucu bir sonuç dosyasına yazar.
• Dosyayı işlerken, dosyanın işlenmesi tamamlanana kadar toplanamayacak çok sayıda birbirine bağlı nesne oluşturur (örneğin bir ayrıştırma ağacı)
• İşlediği dosyalar arasında fazla bir durum tutmaz .

Sen olabilir her dosyayı işlemek zorunda sonra tam bir çöp toplama zorlamak gerektiğini test (dikkatli sonra) dava yapabilmek.

Diğer bir durum, bazı öğeleri işlemek için birkaç dakikada bir uyanan ve uykudayken herhangi bir durumu korumayan bir hizmettir . O zaman uyumadan hemen önce tam bir koleksiyon yapmaya zorlamak faydalı olabilir .

Bir koleksiyonu zorlamayı düşündüğüm tek zaman, yakın zamanda çok sayıda nesnenin oluşturulduğunu ve şu anda çok az nesneye başvurulduğunu bildiğim zamandır.

Kendim için bir GC zorlamak zorunda kalmadan bu tür şeyler hakkında ipuçları verebildiğimde bir çöp toplama API'sine sahip olmayı tercih ederim.

Ayrıca bkz. " Rico Mariani'nin Performans Haberleri "

Rico Mariani tarafından verilen örneğin iyi olduğunu düşünüyorum : Uygulamanın durumunda önemli bir değişiklik varsa bir GC tetiklemek uygun olabilir. Örneğin, bir belge düzenleyicide, bir belge kapatıldığında bir GC'yi tetiklemek TAMAM olabilir.

Programlamada mutlak olan birkaç genel yönerge vardır. Çoğu zaman biri 'yanlış yapıyorsun' dediğinde, sadece belli miktarda dogma mırıldanıyorlar. C'de, kendi kendini değiştiren kod veya iş parçacıkları gibi şeylerden korkuyordu, GC dillerinde GC'yi zorluyor veya alternatif olarak GC'nin çalışmasını engelliyordu.

Çoğu kılavuzda ve iyi pratik kurallarda (ve iyi tasarım uygulamalarında) olduğu gibi, yerleşik norm etrafında çalışmanın mantıklı olduğu nadir durumlar vardır. Vakayı anladığınızdan, davanızın gerçekten genel uygulamadan vazgeçilmesini gerektirdiğinden ve neden olabileceğiniz riskleri ve yan etkileri anladığınızdan çok emin olmalısınız. Ama böyle durumlar var.

Programlama problemleri çok çeşitlidir ve esnek bir yaklaşım gerektirir. Çöp toplanan dillerde ve doğal olarak gerçekleşmesini beklemek yerine onu tetiklemenin mantıklı olduğu yerlerde GC'yi engellemenin mantıklı olduğu durumlar gördüm. Zamanın% 95'inde, bunlardan herhangi biri soruna doğru yaklaşmamış olmanın bir işareti olabilir. Ancak 20'de 1, muhtemelen bunun için yapılacak geçerli bir dava vardır.

Çöp toplama işinin üstesinden gelmemeyi öğrendim. Bununla birlikte, usingdosya G / Ç veya veritabanı bağlantıları gibi yönetilmeyen kaynaklarla uğraşırken anahtar kelimeyi kullanmaya devam ediyorum.

Bunun bir en iyi uygulama olup olmadığından emin değilim, ancak bir döngüde büyük miktarda görüntü ile çalışırken (yani, çok sayıda Grafik / Görüntü / Bitmap nesnesi oluşturup elden çıkarırken) düzenli olarak GC.Collect'e izin veriyorum.

Sanırım bir yerlerde GC'nin yalnızca program (çoğunlukla) boştayken çalıştığını ve yoğun bir döngünün ortasında çalışmadığını okudum, böylece manuel GC'nin mantıklı olabileceği bir alan gibi görünebilir.

Son zamanlarda manuel çağrıların gerekli GC.Collect()olduğu bir durum, küçük yönetilen C ++ nesnelerine sarılmış büyük C ++ nesneleriyle çalışırken, bunlar da C # üzerinden erişiliyordu.

Çöp toplayıcı hiçbir zaman çağrılmadı çünkü kullanılan yönetilen bellek miktarı önemsizdi, ancak kullanılan yönetilmeyen bellek miktarı çok fazlaydı. Dispose()Nesneleri manuel olarak çağırmak , nesnelere artık ihtiyaç duyulmadığında kendi başıma izlememi gerektirirken, arama GC.Collect()artık başvurulmayan nesneleri temizleyecektir .....

En iyi uygulamayı zaten listelediğinizi ve GERÇEKTEN gerekli olmadıkça onu KULLANMAYIN. Önce bu soruları yanıtlamanız gerekiyorsa potansiyel olarak profil oluşturma araçlarını kullanarak kodunuza daha ayrıntılı bir şekilde bakmanızı şiddetle tavsiye ederim.

1. Kodunuzda, öğeleri gerekenden daha geniş bir kapsamda bildiren bir şey var mı
2. Bellek kullanımı gerçekten çok mu yüksek
3. Gerçekten yardımcı olup olmadığını görmek için GC.Collect () kullanmadan önceki ve sonraki performansı karşılaştırın.

Programınızda bellek sızıntısı olmadığını, nesnelerin biriktiğini ve Gen 0'da GC-Edilemeyeceğini varsayalım, çünkü: 1) Uzun süre referans verildiği için Gen1 & Gen2'ye girin; 2) Büyük nesnelerdir (> 80K), bu nedenle LOH (Büyük Nesne Yığını) içine girin. Ve LOH, Gen0, Gen1 ve Gen2'de olduğu gibi sıkıştırma yapmaz.

".NET Belleğinin" performans sayacını kontrol edin, 1) sorunun gerçekten bir sorun olmadığını görebiliyor musunuz? Genel olarak, her 10 Gen0 GC, 1 Gen1 GC'yi ve her 10 Gen1 GC, 1 Gen2 GC'yi tetikleyecektir. Teorik olarak, GC0 üzerinde herhangi bir baskı yoksa (program belleği kullanımı gerçekten kabloluysa) GC1 ve GC2 asla GC-ed olamaz. Benim başıma asla gelmez.

Problem 2 için), LOH'nin şişip şişmediğini doğrulamak için ".NET Belleği" performans sayacını kontrol edebilirsiniz. Sorununuz için gerçekten bir sorunsa, bu blogun önerdiği gibi büyük bir nesne havuzu oluşturabilirsiniz http://blogs.msdn.com/yunjin/archive/2004/01/27/63642.aspx .

Büyük nesneler, gen 0'a değil, LOH'ye (büyük nesne yığını) tahsis edilir. Gen 0 ile çöp olarak toplanmadıklarını söylüyorsanız, haklısınız. Sadece tam GC döngüsü (0, 1 ve 2 nesilleri) gerçekleştiğinde toplandıklarına inanıyorum.

Bununla birlikte, diğer tarafta, büyük nesnelerle çalışırken ve hafıza baskısı artarken, GC'nin hafızayı daha agresif bir şekilde ayarlayıp toplayacağına inanıyorum.

Toplanıp toplanmayacağını ve hangi koşullarda olduğunu söylemek zor. Eskiden GC.Collect () 'i diyalog pencerelerini / formlarını sayısız kontrol vb. İle attıktan sonra yapardım (çünkü form ve kontrolleri birçok iş nesnesi örneği oluşturduğu / çok fazla veri yüklediği için gen 2'de sona erdiğinde - hayır büyük nesneler açıkça), ancak aslında uzun vadede herhangi bir olumlu veya olumsuz etki fark etmedi.

Bunu eklemek isterim: GC.Collect () (+ WaitForPendingFinalizers ()) 'ı çağırmak hikayenin bir parçasıdır. Başkaları tarafından haklı olarak belirtildiği gibi, GC.COllect () deterministik olmayan bir koleksiyondur ve GC'nin kendi takdirine (CLR) bırakılmıştır. WaitForPendingFinalizers'a bir çağrı ekleseniz bile, belirleyici olmayabilir. Bu msdn bağlantısından kodu alın ve 1 veya 2 olarak nesne döngüsü yinelemesiyle kodu çalıştırın. Belirsizliğin ne anlama geldiğini bulacaksınız (nesnenin yıkıcısında bir kırılma noktası ayarlayın). Bekle .. () tarafından yalnızca 1 (veya 2) kalan nesne varken yıkıcı çağrılmaz. [Alıntı gerekli.]

Kodunuz yönetilmeyen kaynaklarla (örn: harici dosya tanıtıcıları) ilgileniyorsa, yıkıcılar (veya sonlandırıcılar) uygulamanız gerekir.

İşte ilginç bir örnek:

Not : Yukarıdaki örneği MSDN'den zaten denediyseniz, aşağıdaki kod havayı temizleyecektir.

class Program
{    
    static void Main(string[] args)
        {
            SomePublisher publisher = new SomePublisher();

            for (int i = 0; i < 10; i++)
            {
                SomeSubscriber subscriber = new SomeSubscriber(publisher);
                subscriber = null;
            }

            GC.Collect();
            GC.WaitForPendingFinalizers();

            Console.WriteLine(SomeSubscriber.Count.ToString());


            Console.ReadLine();
        }
    }

    public class SomePublisher
    {
        public event EventHandler SomeEvent;
    }

    public class SomeSubscriber
    {
        public static int Count;

        public SomeSubscriber(SomePublisher publisher)
        {
            publisher.SomeEvent += new EventHandler(publisher_SomeEvent);
        }

        ~SomeSubscriber()
        {
            SomeSubscriber.Count++;
        }

        private void publisher_SomeEvent(object sender, EventArgs e)
        {
            // TODO: something
            string stub = "";
        }
    }

Önce çıktının ne olabileceğini analiz edin ve ardından çalıştırın ve ardından aşağıdaki nedeni okuyun:

{Yıkıcı, yalnızca program sona erdiğinde dolaylı olarak çağrılır. } Nesneyi belirleyici olarak temizlemek için, IDisposable uygulaması ve açık bir Dispose () çağrısı yapılmalıdır. Öz bu! :)

Bir şey daha, GC Collect'in açıkça tetiklenmesi programınızın performansını ARTIRMAYABİLİR. Daha da kötüleştirmek oldukça mümkün.

.NET GC iyi tasarlanmış ve uyarlanabilir olacak şekilde ayarlanmıştır, yani program belleği kullanımınızın "alışkanlığına" göre GC0 / 1/2 eşiğini ayarlayabilir. Böylece, bir süre çalıştıktan sonra programınıza uyarlanacaktır. GC.Collect'i açıkça çağırdığınızda, eşikler sıfırlanacaktır! Ve .NET, programınızın "alışkanlığına" yeniden adapte olmak için zaman harcamalıdır.

Önerim her zaman .NET GC'ye güvenmektir. Herhangi bir bellek sorunu yüzeyinde, ".NET Belleği" performans sayacını kontrol edin ve kendi kodumu tanılayın.

En iyi uygulama olup olmadığından emin değilim ...

Öneri: emin olmadığınızda bunu veya herhangi bir şeyi uygulamayın. Gerçekler bilindiğinde yeniden değerlendirin, ardından doğrulamak için performans testlerinden önce / sonra gerçekleştirin.

Ancak, Collect () çağrısının olumsuz bir etkisi olmayacağını doğrulamak için kodunuzu güvenilir bir şekilde test edebilirseniz, devam edin ...

IMHO, bu "Programınızın gelecekte hiçbir zaman hataya sahip olmayacağını ispatlayabilirseniz, devam edin ..." demeye benzer.

Ciddiyetle, GC'yi zorlamak hata ayıklama / test etme amaçları için yararlıdır. Başka zamanlarda yapmanız gerektiğini düşünüyorsanız, ya yanılıyorsunuz ya da programınız yanlış oluşturulmuştur. Her iki durumda da çözüm GC'yi zorlamıyor ...