MemoryFailPoint 클래스

정의

작업을 실행하기 전에 메모리 리소스가 충분한지 확인합니다.Checks for sufficient memory resources before executing an operation. 이 클래스는 상속될 수 없습니다.This class cannot be inherited.

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
상속
구현

예제

MemoryFailPoint 메모리 부족으로 인 한 손상을 방지 하려면 자체를 애플리케이션을 수 있습니다.MemoryFailPoint enables an application to slow itself to avoid running out of memory in a corrupting manner. 어휘 범위 내에서 사용 해야 합니다.It should be used within a lexical scope. 다음 예제에서는 작업 큐에 항목을 처리 하는 스레드를 시작 합니다.The following example launches threads to process items in a work queue. 사용 가능한 메모리 리소스를 사용 하 여이 확인은 각 스레드를 시작 하기 전에 MemoryFailPoint입니다.Before each thread is launched, the available memory resources are checked using MemoryFailPoint. 예외가 throw 되 면 main 메서드에 다음 스레드를 시작 하기 전에 사용 가능한 메모리를 대기 합니다.If an exception is thrown, the main method waits until memory is available before launching the next thread.

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

    }
}

설명

참고

이 클래스는 고급 개발에 사용 하 여 위한 것입니다.This class is intended for use in advanced development.

인스턴스를 만들지는 MemoryFailPoint 클래스는 메모리 게이트를 만듭니다.Creating an instance of the MemoryFailPoint class creates a memory gate. 메모리 게이트는 많은 양의 메모리가 필요한 작업을 시작 하기 전에 리소스가 충분 한지 확인 합니다.A memory gate checks for sufficient resources before initiating an activity that requires a large amount of memory. 결과 검사 실패는 InsufficientMemoryException 예외가 throw 됩니다.Failing the check results in an InsufficientMemoryException exception being thrown. 이 예외는 작업을 시작 하는 것을 방지 하며 리소스 부족으로 인해 오류의 가능성을 줄여 줍니다.This exception prevents an operation from being started and reduces the possibility of failure due to lack of resources. 이 사용 하도록이 설정 하면 성능을 저하 시킬 않으려면는 OutOfMemoryException 예외 및 잘못 된 코드의 임의 위치에서 예외 처리에서 발생할 수 있는 상태 손상 됩니다.This enables you decrease performance to avoid an OutOfMemoryException exception and any state corruption that may result from improper handling of the exception in arbitrary locations in your code.

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다.This type implements the IDisposable interface. 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로의 삭제 해야 있습니다.When you have finished using the type, you should dispose of it either directly or indirectly. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try / catch 블록입니다.To dispose of the type directly, call its Dispose method in a try/catch block. 삭제 하지 직접, 언어 구문 같은 사용 using (C#에서) 또는 Using (Visual Basic에서는).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 자세한 내용은 "를 사용 하는 개체는 구현 IDisposable" 섹션을 참조 하세요.를 IDisposable 인터페이스 항목입니다.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Throw 하 여는 InsufficientMemoryException 예외를 애플리케이션 작업을 완료할 수 될 예상 사이의 애플리케이션 상태 손상 되었을 수 있습니다는 부분적으로 완료 된 작업을 구분할 수 있습니다.By throwing an InsufficientMemoryException exception, an application can distinguish between an estimate that an operation will not be able to complete and a partially completed operation that may have corrupted the application state. 이렇게 하면 현재 언로드 필요할 수 있는 비관적 에스컬레이션 정책의 빈도를 줄이려면 애플리케이션 AppDomain 프로세스를 재생 합니다.This allows an application to reduce the frequency of a pessimistic escalation policy, which may require unloading the current AppDomain or recycling the process.

MemoryFailPoint 충분 한 메모리 및 연속 된 가상 주소 공간 힙 모든 가비지 컬렉션에서 사용할 수 있는 고 스왑 파일의 크기를 늘릴 수 있습니다를 확인 합니다.MemoryFailPoint checks to see whether sufficient memory and consecutive virtual address space are available in all garbage collection heaps, and may increase the size of the swap file. MemoryFailPoint 메모리의 장기 가용성에 대 한 게이트를 하지만 호출자의 수명 동안 보장 되지 않습니다는 항상 사용 해야 합니다 Dispose 와 관련 된 리소스를 확인 하는 방법 MemoryFailPoint 릴리스됩니다.MemoryFailPoint makes no guarantees regarding the long-term availability of the memory during the lifetime of the gate, but callers should always use the Dispose method to ensure that resources associated with MemoryFailPoint are released.

메모리 게이트를 사용 하려면 만들어야를 MemoryFailPoint 개체 및 메모리의 메가바이트 (MB)의 수를 지정 하면 다음 작업을 사용 하 여 예상 되는 합니다.To use a memory gate, you must create a MemoryFailPoint object and specify the number of megabytes (MB) of memory that the next operation is expected to use. 충분 한 메모리를 사용할 수 없는 경우는 InsufficientMemoryException 예외가 throw 됩니다.If enough memory is not available, an InsufficientMemoryException exception is thrown.

생성자의 매개 변수는 양의 정수 여야 합니다.The parameter of the constructor must be a positive integer. 음수 값을 발생 시킵니다는 ArgumentOutOfRangeException 예외입니다.A negative value raises an ArgumentOutOfRangeException exception.

MemoryFailPoint 16MB의 세분성에서 작동합니다.MemoryFailPoint operates at a granularity of 16 MB. 16MB 보다 작은 모든 값은 16MB으로 처리 하 고 다른 값으로 최대 16MB의 배수로 처리 됩니다.Any values smaller than 16 MB are treated as 16 MB, and other values are treated as the next largest multiple of 16 MB.

생성자

MemoryFailPoint(Int32)

성공적으로 실행하는 데 필요한 메모리 양을 지정하여 MemoryFailPoint 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MemoryFailPoint class, specifying the amount of memory required for successful execution.

메서드

Dispose()

MemoryFailPoint에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the MemoryFailPoint.

Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
Finalize()

가비지 컬렉션기에서 MemoryFailPoint 개체를 회수할 때 리소스가 해제되고 다른 정리 작업이 수행되도록 합니다.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the MemoryFailPoint object.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)

보안

SecurityPermission
비관리 코드를 호출 합니다.for calling unmanaged code. 연관된 열거형: UnmanagedCodeAssociated enumeration: UnmanagedCode. 보안 작업: LinkDemandSecurity action: LinkDemand

적용 대상