Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

AbandonedMutexException-Klasse

 

Veröffentlicht: Oktober 2016

Diese Ausnahme wird ausgelöst, wenn ein Thread erhält ein Mutex Objekt, das einem anderen Thread abgebrochen wurde, indem Sie Beenden nicht freigegeben wurde.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Exception
    System.SystemException
      System.Threading.AbandonedMutexException

[SerializableAttribute]
[ComVisibleAttribute(false)]
public class AbandonedMutexException : SystemException

NameBeschreibung
System_CAPS_pubmethodAbandonedMutexException()

Initialisiert eine neue Instanz der AbandonedMutexException-Klasse mit Standardwerten.

System_CAPS_pubmethodAbandonedMutexException(Int32, WaitHandle)

Initialisiert eine neue Instanz der AbandonedMutexException -Klasse mit einem angegebenen Index für den abgebrochenen Mutex, falls zutreffend, und einem Mutex -Objekt, das den Mutex darstellt.

System_CAPS_protmethodAbandonedMutexException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der AbandonedMutexException-Klasse mit serialisierten Daten.

System_CAPS_pubmethodAbandonedMutexException(String)

Initialisiert eine neue Instanz der AbandonedMutexException-Klasse mit einer angegebenen Fehlermeldung.

System_CAPS_pubmethodAbandonedMutexException(String, Exception)

Initialisiert eine neue Instanz der AbandonedMutexException -Klasse mit einer angegebenen Fehlermeldung und inneren Ausnahme.

System_CAPS_pubmethodAbandonedMutexException(String, Exception, Int32, WaitHandle)

Initialisiert eine neue Instanz der AbandonedMutexException -Klasse mit einer angegebenen Fehlermeldung, der die innere Ausnahme, den Index für den abgebrochenen Mutex, falls zutreffend, und einem Mutex -Objekt, das den Mutex darstellt.

System_CAPS_pubmethodAbandonedMutexException(String, Int32, WaitHandle)

Initialisiert eine neue Instanz der dem AbandonedMutexException Nachricht Klasse mit einer angegebenen Fehlermeldung, der den Index des abgebrochenen Mutex, falls zutreffend, und der abgebrochenen Mutex.

NameBeschreibung
System_CAPS_pubpropertyData

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.(Geerbt von „Exception“.)

System_CAPS_pubpropertyHelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.(Geerbt von „Exception“.)

System_CAPS_pubpropertyHResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.(Geerbt von „Exception“.)

System_CAPS_pubpropertyInnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.(Geerbt von „Exception“.)

System_CAPS_pubpropertyMessage

Ruft eine Meldung ab, die die aktuelle Ausnahme beschreibt.(Geerbt von „Exception“.)

System_CAPS_pubpropertyMutex

Ruft den abgebrochenen Mutex, der die Ausnahme verursacht hat, sofern bekannt.

System_CAPS_pubpropertyMutexIndex

Ruft den Index des abgebrochenen Mutex, der die Ausnahme verursacht hat, sofern bekannt.

System_CAPS_pubpropertySource

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.(Geerbt von „Exception“.)

System_CAPS_pubpropertyStackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.(Geerbt von „Exception“.)

System_CAPS_pubpropertyTargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.(Geerbt von „Exception“.)

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.(Geerbt von „Exception“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.(Geerbt von „Exception“.)

System_CAPS_pubmethodGetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.(Geerbt von „Exception“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.(Geerbt von „Exception“.)

NameBeschreibung
System_CAPS_proteventSerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt zu erstellen, das serialisierte Daten für die Ausnahme enthält.(Geerbt von „Exception“.)

Wenn ein Thread einen Mutex abbricht, wird die Ausnahme im nächsten Thread ausgelöst, der den Mutex verwendet. Der Thread kann den Mutex abrufen, weil er bereits auf den Mutex gewartet hat oder weil er zu einem späteren Zeitpunkt in der Mutex aufgehoben wird.

Ein abgebrochenes Mutex weist einen schwerwiegenden Programmierfehler. Wenn ein Thread beendet, ohne das Mutex freizugeben, möglicherweise die vom Mutex geschützte Datenstruktur möglicherweise nicht in einem konsistenten Zustand. Vor Version 2.0 von .NET Framework konnten derartige Probleme nur schwer zu ermitteln, da keine Ausnahme ausgelöst wurde, wenn ein Wartezustand als Ergebnis ein abgebrochenes Mutex. Weitere Informationen finden Sie in den Ausführungen zur Mutex-Klasse.

Der nächste Thread, der Besitz des Mutex anfordert, kann diese Ausnahme behandeln und fortfahren, wenn die Integrität der Datenstruktur überprüft werden kann.

Im folgenden Codebeispiel wird einen Thread, der fünf Mutexe, veranschaulicht die Auswirkungen auf abbricht führt die WaitOne, WaitAny, und WaitAll Methoden. Der Wert des der MutexIndex -Eigenschaft wird angezeigt, für die WaitAny aufrufen.

System_CAPS_noteHinweis

Der Aufruf der WaitAny Methode wird von einem der abgebrochenen Mutexe unterbrochen. Der andere abgebrochene Mutex kann immer noch eine AbandonedMutexException durch nachfolgende wartende Methoden ausgelöst wird.


using System;
using System.Threading;

public class Example
{
    private static ManualResetEvent _dummy = new ManualResetEvent(false);

    private static Mutex _orphan1 = new Mutex();
    private static Mutex _orphan2 = new Mutex();
    private static Mutex _orphan3 = new Mutex();
    private static Mutex _orphan4 = new Mutex();
    private static Mutex _orphan5 = new Mutex();

    [MTAThread]
    public static void Main()
    {
        // Start a thread that takes all five mutexes, and then
        // ends without releasing them.
        //
        Thread t = new Thread(new ThreadStart(AbandonMutex));
        t.Start();
        // Make sure the thread is finished.
        t.Join();

        // Wait on one of the abandoned mutexes. The WaitOne returns
        // immediately, because its wait condition is satisfied by
        // the abandoned mutex, but on return it throws
        // AbandonedMutexException.
        try
        {
            _orphan1.WaitOne();
            Console.WriteLine("WaitOne succeeded.");
        }
        catch(AbandonedMutexException ex)
        {
            Console.WriteLine("Exception on return from WaitOne." +
                "\r\n\tMessage: {0}", ex.Message);
        }
        finally
        {
            // Whether or not the exception was thrown, the current
            // thread owns the mutex, and must release it.
            //
            _orphan1.ReleaseMutex();
        }

        // Create an array of wait handles, consisting of one
        // ManualResetEvent and two mutexes, using two more of the
        // abandoned mutexes.
        WaitHandle[] waitFor = {_dummy, _orphan2, _orphan3};

        // WaitAny returns when any of the wait handles in the 
        // array is signaled, so either of the two abandoned mutexes
        // satisfy its wait condition. On returning from the wait,
        // WaitAny throws AbandonedMutexException. The MutexIndex
        // property returns the lower of the two index values for 
        // the abandoned mutexes. Note that the Try block and the
        // Catch block obtain the index in different ways.
        //  
        try
        {
            int index = WaitHandle.WaitAny(waitFor);
            Console.WriteLine("WaitAny succeeded.");

            // The current thread owns the mutex, and must release
            // it.
            Mutex m = waitFor[index] as Mutex;
            if (m != null) m.ReleaseMutex();
        }
        catch(AbandonedMutexException ex)
        {
            Console.WriteLine("Exception on return from WaitAny at index {0}." +
                "\r\n\tMessage: {1}", ex.MutexIndex, ex.Message);

            // Whether or not the exception was thrown, the current
            // thread owns the mutex, and must release it.
            //
            if (ex.Mutex != null) ex.Mutex.ReleaseMutex();
        }

        // Use two more of the abandoned mutexes for the WaitAll call.
        // WaitAll doesn't return until all wait handles are signaled,
        // so the ManualResetEvent must be signaled by calling Set().
        _dummy.Set();
        waitFor[1] = _orphan4;
        waitFor[2] = _orphan5;

        // The signaled event and the two abandoned mutexes satisfy
        // the wait condition for WaitAll, but on return it throws
        // AbandonedMutexException. For WaitAll, the MutexIndex
        // property is always -1 and the Mutex property is always
        // null.
        //  
        try
        {
            WaitHandle.WaitAll(waitFor);
            Console.WriteLine("WaitAll succeeded.");
        }
        catch(AbandonedMutexException ex)
        {
            Console.WriteLine("Exception on return from WaitAll. MutexIndex = {0}." +
                "\r\n\tMessage: {1}", ex.MutexIndex, ex.Message);
        }
        finally
        {
            // Whether or not the exception was thrown, the current
            // thread owns the mutexes, and must release them.
            //
            _orphan4.ReleaseMutex();
            _orphan5.ReleaseMutex();
        }
    }

    [MTAThread]
    public static void AbandonMutex()
    {
        _orphan1.WaitOne();
        _orphan2.WaitOne();
        _orphan3.WaitOne();
        _orphan4.WaitOne();
        _orphan5.WaitOne();
        // Abandon the mutexes by exiting without releasing them.
        Console.WriteLine("Thread exits without releasing the mutexes.");
    }
}

/* This code example produces the following output:

Thread exits without releasing the mutexes.
Exception on return from WaitOne.
        Message: The wait completed due to an abandoned mutex.
Exception on return from WaitAny at index 1.
        Message: The wait completed due to an abandoned mutex.
Exception on return from WaitAll. MutexIndex = -1.
        Message: The wait completed due to an abandoned mutex.
 */

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Windows Phone Silverlight
Verfügbar seit 8.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: