MemoryFailPoint Osztály

Definíció

Névtér:

System.Runtime

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

MemoryFailPoint.cs

A művelet végrehajtása előtt ellenőrzi a megfelelő memóriaerőforrásokat. Ez az osztály nem örökölhető.

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

Öröklődés

Object

CriticalFinalizerObject

MemoryFailPoint

Megvalósítás

IDisposable

Példák

MemoryFailPoint lehetővé teszi, hogy az alkalmazás lelassítsa magát, hogy ne fogyjon el a memória sérült módon. Lexikális hatókörben kell használni. Az alábbi példa szálakat indít el a munkasor elemeinek feldolgozásához. Az egyes szálak elindítása előtt a rendszer ellenőrzi MemoryFailPointa rendelkezésre álló memóriaerőforrásokat. Kivétel esetén a fő metódus megvárja, amíg a következő szál indítása előtt rendelkezésre áll a memória.

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);
    }
}

Megjegyzések

Note

Ez az osztály speciális fejlesztéshez használható.

Az osztály egy példányának MemoryFailPoint létrehozása memóriakaput hoz létre. A memóriakapu a nagy mennyiségű memóriát igénylő tevékenység megkezdése előtt ellenőrzi a megfelelő erőforrásokat. Az ellenőrzés sikertelensége kivételt eredményez InsufficientMemoryException . Ez a kivétel megakadályozza a művelet indítását, és csökkenti az erőforrások hiánya miatti meghibásodás lehetőségét. Ez lehetővé teszi, hogy csökkentse a teljesítményt, hogy elkerülje a kivételt OutOfMemoryException és az állapot sérülését, amely a kivétel helytelen kezeléséből eredhet a kód tetszőleges helyeiben.

Important

Ez a típus implementálja a IDisposable felületet. Ha befejezte a típus használatát, közvetlenül (a metódus meghívásával) vagy közvetetten (például using a C#-ban) kell elhelyeznie Dispose a típust. További információ: Az IDisposable-t megvalósító objektum használata.

Egy kivétel kivetésével InsufficientMemoryException az alkalmazás különbséget tehet egy olyan becslés között, amely szerint egy művelet nem fejeződhet be, és egy részben befejezett művelet, amely sérült lehet az alkalmazás állapotában. Ez lehetővé teszi, hogy az alkalmazás csökkentse a pesszimista eszkalációs szabályzatok gyakoriságát, ami szükségessé teheti az aktuális AppDomain vagy a folyamat újrahasznosítását.

MemoryFailPoint ellenőrzi, hogy elegendő memória és egymást követő virtuális címtér áll-e rendelkezésre az összes szemétgyűjtési halomban, és növelheti a felcserélési fájl méretét. MemoryFailPoint nem garantálja a memória hosszú távú rendelkezésre állását a kapu élettartama alatt, de a hívóknak mindig ezzel a Dispose módszerrel kell gondoskodniuk arról, hogy a társított MemoryFailPoint erőforrások felszabaduljanak.

Memóriakapu használatához létre kell hoznia egy MemoryFailPoint objektumot, és meg kell adnia a memória azon megabájtjainak (MB) számát, amelyet a következő művelet várhatóan használni fog. Ha nem áll rendelkezésre elegendő memória, a rendszer kivételt InsufficientMemoryException jelez.

A konstruktor paraméterének pozitív egész számnak kell lennie. A negatív érték vagy a 0 kivételt ArgumentOutOfRangeException eredményez.

MemoryFailPoint 16 MB részletességgel működik. A 16 MB-nál kisebb értékek 16 MB-ként lesznek kezelve, a többi érték pedig a 16 MB következő legnagyobb többszöröse.

Konstruktorok

Name	Description
MemoryFailPoint(Int32)	Inicializálja az MemoryFailPoint osztály új példányát, megadva a sikeres végrehajtáshoz szükséges memória mennyiségét.

Metódusok

Name	Description
Dispose()	Felszabadítja a .-hez használt összes erőforrást MemoryFailPoint.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Finalize()	Biztosítja, hogy az erőforrások felszabadítva legyenek, és más tisztítási műveletek is végrehajtva legyenek, amikor a szemétgyűjtő visszanyeri az MemoryFailPoint objektumot.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)