MemoryFailPoint Sınıf

Tanım

Ad Alanı:

System.Runtime

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

MemoryFailPoint.cs

bir işlemi yürütmeden önce yeterli bellek kaynaklarını denetler. Bu sınıf devralınamaz.

public ref class MemoryFailPoint sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, IDisposable

public sealed class MemoryFailPoint : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, IDisposable

type MemoryFailPoint = class
    inherit CriticalFinalizerObject
    interface IDisposable

Public NotInheritable Class MemoryFailPoint
Inherits CriticalFinalizerObject
Implements IDisposable

Devralma

Object

CriticalFinalizerObject

MemoryFailPoint

Uygulamalar

IDisposable

Örnekler

MemoryFailPoint , bir uygulamanın belleğin bozuk bir şekilde bitmesi önlemek için kendisini yavaşlatmasını sağlar. Sözcük temelli bir kapsam içinde kullanılmalıdır. Aşağıdaki örnek, iş kuyruğundaki öğeleri işlemek için iş parçacıklarını başlatır. Her iş parçacığı başlatılmadan önce kullanılabilir bellek kaynakları kullanılarak MemoryFailPointdenetleniyor. Bir özel durum oluşursa, ana yöntem bir sonraki iş parçacığını başlatmadan önce bellek kullanılabilir olana kadar bekler.

using System;
using System.Runtime;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.Collections;

class MemoryFailPointExample
{
    // Allocate in chunks of 64 megabytes.
    private const uint chunkSize = 64 << 20;
    // Use more than the total user-available address space (on 32 bit machines)
    // to drive towards getting an InsufficientMemoryException.
    private const uint numWorkItems = 1 + ((1U << 31) / chunkSize);
    static Queue workQueue = new Queue(50);

    // This value can be computed separately and hard-coded into the application.
    // The method is included to illustrate the technique.
    private static int EstimateMemoryUsageInMB()
    {
        int memUsageInMB = 0;

        long memBefore = GC.GetTotalMemory(true);
        int numGen0Collections = GC.CollectionCount(0);
        // Execute a test version of the method to estimate memory requirements.
        // This test method only exists to determine the memory requirements.
        ThreadMethod();
        // Includes garbage generated by the worker function.
        long memAfter = GC.GetTotalMemory(false);
        // If a garbage collection occurs during the measuring, you might need a greater memory requirement.
        Console.WriteLine("Did a GC occur while measuring?  {0}", numGen0Collections == GC.CollectionCount(0));
        // Set the field used as the parameter for the MemoryFailPoint constructor.
        long memUsage = (memAfter - memBefore);
        if (memUsage < 0)
        {
            Console.WriteLine("GC's occurred while measuring memory usage.  Try measuring again.");
            memUsage = 1 << 20;
        }

        // Round up to the nearest MB.
        memUsageInMB = (int)(1 + (memUsage >> 20));
        Console.WriteLine("Memory usage estimate: {0} bytes, rounded to {1} MB", memUsage, memUsageInMB);
        return memUsageInMB;
    }

    static void Main()
    {
        Console.WriteLine("Attempts to allocate more than 2 GB of memory across worker threads.");
        int memUsageInMB = EstimateMemoryUsageInMB();

        // For a production application consider using the threadpool instead.
        Thread[] threads = new Thread[numWorkItems];
        // Create a work queue to be processed by multiple threads.
        int n = 0;
        for (n = 0; n < numWorkItems; n++)
            workQueue.Enqueue(n);
        // Continue to launch threads until the work queue is empty.
        while (workQueue.Count > 0)
        {
            Console.WriteLine(" GC heap (live + garbage): {0} MB", GC.GetTotalMemory(false) >> 20);
            MemoryFailPoint memFailPoint = null;
            try
            {
                // Check for available memory.
                memFailPoint = new MemoryFailPoint(memUsageInMB);
                n = (int)workQueue.Dequeue();
                threads[n] =
                    new Thread(new ParameterizedThreadStart(ThreadMethod));
                WorkerState state = new WorkerState(n, memFailPoint);
                threads[n].Start(state);
                Thread.Sleep(10);
            }
            catch (InsufficientMemoryException e)
            {
                // MemoryFailPoint threw an exception, handle by sleeping for a while,  then
                // continue processing the queue.
                Console.WriteLine("Expected InsufficientMemoryException thrown.  Message: " + e.Message);
                // We could optionally sleep until a running worker thread
                // has finished, like this:  threads[joinCount++].Join();
                Thread.Sleep(1000);
            }
        }

        Console.WriteLine("WorkQueue is empty - blocking to ensure all threads quit (each thread sleeps for 10 seconds)");
        foreach (Thread t in threads)
            t.Join();
        Console.WriteLine("All worker threads are finished - exiting application.");
    }

    // Test version of the working code to determine memory requirements.
    static void ThreadMethod()
    {
        byte[] bytes = new byte[chunkSize];
    }

    internal class WorkerState
    {
        internal int _threadNumber;
        internal MemoryFailPoint _memFailPoint;

        internal WorkerState(int threadNumber, MemoryFailPoint memoryFailPoint)
        {
            _threadNumber = threadNumber;
            _memFailPoint = memoryFailPoint;
        }

        internal int ThreadNumber
        {
            get { return _threadNumber; }
        }

        internal MemoryFailPoint MemoryFailPoint
        {
            get { return _memFailPoint; }
        }
    }

    // The method that does the work.
    static void ThreadMethod(Object o)
    {
        WorkerState state = (WorkerState)o;
        Console.WriteLine("Executing ThreadMethod, " +
            "thread number {0}.", state.ThreadNumber);
        byte[] bytes = null;
        try
        {
            bytes = new byte[chunkSize];
            // Allocated all the memory needed for this workitem.
            // Now dispose of the MemoryFailPoint, then process the workitem.
            state.MemoryFailPoint.Dispose();
        }
        catch (OutOfMemoryException oom)
        {
            Console.Beep();
            Console.WriteLine("Unexpected OutOfMemory exception thrown: " + oom);
        }

        // Do work here, possibly taking a lock if this app needs
        // synchronization between worker threads and/or the main thread.

        // Keep the thread alive for awhile to simulate a running thread.
        Thread.Sleep(10000);

        // A real thread would use the byte[], but to be an illustrative sample,
        // explicitly keep the byte[] alive to help exhaust the memory.
        GC.KeepAlive(bytes);
        Console.WriteLine("Thread {0} is finished.", state.ThreadNumber);
    }
}

Açıklamalar

Not

Bu sınıf, gelişmiş geliştirmede kullanılmak üzere tasarlanmıştır.

sınıfının bir örneğini MemoryFailPoint oluşturmak bir bellek geçidi oluşturur. Bellek kapısı, büyük miktarda bellek gerektiren bir etkinliği başlatmadan önce yeterli kaynakları denetler. Denetimin başarısız olması bir InsufficientMemoryException özel durumun oluştuğuna neden olur. Bu özel durum, bir işlemin başlatılmasını engeller ve kaynak yetersizliğinden dolayı hata olasılığını azaltır. Bu, bir OutOfMemoryException özel durumu ve kodunuzdaki rastgele konumlarda özel durumun yanlış işlenmesinden kaynaklanabilir durum bozulmalarını önlemek için performansı azaltmanıza olanak tanır.

Önemli

Bu tür arabirimini IDisposable uygular. Türünü kullanmayı bitirdiğinizde, doğrudan veya dolaylı olarak atmalısınız. Türü doğrudan atmak için yöntemini bir try/catch blokta çağırın.Dispose Bunu dolaylı olarak atmak için (C#'ta) veya Using (Visual Basic'te) gibi using bir dil yapısı kullanın. Daha fazla bilgi için arabirim konusunun "IDisposable Uygulayan Bir Nesne Kullanma" bölümüne IDisposable bakın.

Bir uygulama, bir InsufficientMemoryException özel durum oluşturarak bir işlemin tamamlanamadısına ilişkin bir tahmin ile uygulama durumunu bozmuş olabilecek kısmen tamamlanmış bir işlem arasında ayrım yapabilir. Bu, bir uygulamanın kötümser bir yükseltme ilkesinin sıklığını azaltmasına olanak tanır ve bu da geçerli AppDomain işlemin kaldırılmasını veya geri dönüştürülmesini gerektirebilir.

MemoryFailPoint tüm çöp toplama yığınlarında yeterli bellek ve ardışık sanal adres alanı olup olmadığını denetler ve takas dosyasının boyutunu artırabilir. MemoryFailPointgeçidin kullanım ömrü boyunca belleğin uzun süreli kullanılabilirliğiyle ilgili hiçbir garanti sağlamaz, ancak çağıranlar her zaman ile MemoryFailPoint ilişkili kaynakların serbest bırakılmasını sağlamak için yöntemini kullanmalıdırDispose.

Bellek geçidi kullanmak için bir nesne oluşturmanız ve bir MemoryFailPoint sonraki işlemin kullanması beklenen megabayt (MB) bellek sayısını belirtmeniz gerekir. Yeterli bellek yoksa, bir InsufficientMemoryException özel durum oluşturulur.

Oluşturucunun parametresi pozitif bir tamsayı olmalıdır. Negatif bir değer özel durum ArgumentOutOfRangeException oluşturur.

MemoryFailPoint 16 MB ayrıntı düzeyinde çalışır. 16 MB'tan küçük değerler 16 MB, diğer değerler ise 16 MB'ın sonraki en büyük katı olarak kabul edilir.

Oluşturucular

MemoryFailPoint(Int32)

Başarılı bir yürütme için gereken bellek miktarını belirterek sınıfının yeni bir örneğini MemoryFailPoint başlatır.

Yöntemler

Dispose()	MemoryFailPoint tarafından kullanılan tüm kaynakları serbest bırakır.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Finalize()	Atık toplayıcı nesneyi geri kazandığında kaynakların serbest kalmasını ve diğer temizleme işlemlerinin gerçekleştirilmesini MemoryFailPoint sağlar.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)