AbandonedMutexException Classe

Définition

Espace de noms:

System.Threading

Assembly:

System.Threading.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Exception levée lorsqu'un thread acquiert un objet Mutex qu'un autre thread a abandonné en se terminant sans le libérer.

C#

public class AbandonedMutexException : Exception

C#

public class AbandonedMutexException : SystemException

C#

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class AbandonedMutexException : SystemException

Héritage

Object

Exception

AbandonedMutexException

Héritage

Object

Exception

SystemException

AbandonedMutexException

Attributs

ComVisibleAttribute SerializableAttribute

Exemples

L’exemple de code suivant exécute un thread qui abandonne cinq mutex, démontrant leurs effets sur le WaitOne, WaitAnyet WaitAll les méthodes. La valeur de la MutexIndex propriété est affichée pour l’appel WaitAny .

Note

L’appel à la WaitAny méthode est interrompu par l’un des mutex abandonnés. L’autre mutex abandonné peut toujours provoquer une AbandonedMutexException levée par les méthodes d’attente suivantes.

C#

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.
 */

Remarques

Lorsqu’un thread abandonne un mutex, l’exception est levée dans le thread suivant qui acquiert le mutex. Le thread peut acquérir le mutex, car il attendait déjà le mutex ou parce qu’il entre dans le mutex ultérieurement.

Un mutex abandonné indique une erreur de programmation grave. Lorsqu’un thread se ferme sans libérer le mutex, les structures de données protégées par le mutex peuvent ne pas être dans un état cohérent. Avant la version 2.0 du .NET Framework, de tels problèmes étaient difficiles à détecter, car aucune exception n’a été levée si une attente s’est terminée en raison d’un mutex abandonné. Pour plus d'informations, consultez la classe Mutex.

Le thread suivant pour demander la propriété du mutex peut gérer cette exception et continuer, à condition que l’intégrité des structures de données puisse être vérifiée.

Constructeurs

AbandonedMutexException()	Initialise une nouvelle instance de la classe AbandonedMutexException avec des valeurs par défaut.
AbandonedMutexException(Int32, WaitHandle)	Initialise une nouvelle instance de la classe AbandonedMutexException avec un index spécifié pour le mutex abandonné, le cas échéant, et un objet Mutex qui représente le mutex.
AbandonedMutexException(SerializationInfo, StreamingContext)	Initialise une nouvelle instance de la classe AbandonedMutexException avec des données sérialisées.
AbandonedMutexException(String)	Initialise une nouvelle instance de la classe AbandonedMutexException avec un message d'erreur spécifié.
AbandonedMutexException(String, Exception)	Initialise une nouvelle instance de la classe AbandonedMutexException avec un message d'erreur et une exception interne spécifiés.
AbandonedMutexException(String, Exception, Int32, WaitHandle)	Initialise une nouvelle instance de la classe AbandonedMutexException avec un message d'erreur spécifié, l'exception interne, l'index pour le mutex abandonné, le cas échéant, et un objet Mutex qui représente le mutex.
AbandonedMutexException(String, Int32, WaitHandle)	Initialise une nouvelle instance de la classe AbandonedMutexException avec un message d'erreur spécifié, l'index du mutex abandonné, le cas échéant, et le mutex abandonné.

Propriétés

Data	Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception. (Hérité de Exception)
HelpLink	Obtient ou définit un lien vers le fichier d'aide associé à cette exception. (Hérité de Exception)
HResult	Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique. (Hérité de Exception)
InnerException	Obtient l'instance Exception qui a provoqué l'exception actuelle. (Hérité de Exception)
Message	Obtient un message qui décrit l'exception active. (Hérité de Exception)
Mutex	Obtient le mutex abandonné qui a provoqué l'exception, s'il est connu.
MutexIndex	Obtient l'index du mutex abandonné qui a provoqué l'exception, s'il est connu.
Source	Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur. (Hérité de Exception)
StackTrace	Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels. (Hérité de Exception)
TargetSite	Obtient la méthode qui lève l'exception actuelle. (Hérité de Exception)

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetBaseException()	En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures. (Hérité de Exception)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)	En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception. (Hérité de Exception)
GetType()	Obtient le type au moment de l'exécution de l'instance actuelle. (Hérité de Exception)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Crée et retourne une chaîne représentant l'exception actuelle. (Hérité de Exception)

Événements

SerializeObjectState

Obsolète. Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception. (Hérité de Exception)

S’applique à

Voir aussi

• Mutex
• Mutex