AbandonedMutexException 类

定义

命名空间:

System.Threading

程序集:

System.Threading.dll

程序集:

mscorlib.dll

程序集:

netstandard.dll

当某个线程获取由另一个线程放弃（即在未释放的情况下退出）的 Mutex 对象时引发的异常。

C#

public class AbandonedMutexException : Exception

C#

public class AbandonedMutexException : SystemException

C#

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

继承

Object

Exception

AbandonedMutexException

继承

Object

Exception

SystemException

AbandonedMutexException

属性

ComVisibleAttribute SerializableAttribute

示例

下面的代码示例执行一个线程，该线程放弃五个互斥体，演示了它们对WaitOne和WaitAnyWaitAll方法的影响。 为调用显示WaitAny属性的值MutexIndex。

备注

对方法的 WaitAny 调用被一个废弃的互斥体中断。 另一个废弃的互斥体仍可能导致 AbandonedMutexException 后续等待方法引发。

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

注解

当线程放弃互斥体时，将在获取互斥体的下一个线程中引发异常。 线程可能会获取互斥体，因为它已经在等待互斥体，或者因为它稍后进入互斥体。

废弃的互斥体表示严重的编程错误。 当线程在不释放互斥体的情况下退出时，受互斥体保护的数据结构可能不处于一致状态。 在.NET Framework版本 2.0 之前，此类问题很难发现，因为如果由于废弃的互斥表达式而完成等待，则不会引发异常。 有关更多信息，请参见 Mutex 类。

请求互斥体所有权的下一个线程可以处理此异常并继续，前提是可以验证数据结构的完整性。

构造函数

AbandonedMutexException()	使用默认值初始化 AbandonedMutexException 类的新实例。
AbandonedMutexException(Int32, WaitHandle)	用被放弃的互斥体的指定索引（如果可用）和表示该互斥体的 AbandonedMutexException 对象初始化 Mutex 类的新实例。
AbandonedMutexException(SerializationInfo, StreamingContext)	用序列化数据初始化 AbandonedMutexException 类的新实例。
AbandonedMutexException(String)	用指定的错误消息初始化 AbandonedMutexException 类的新实例。
AbandonedMutexException(String, Exception)	用指定的错误信息和内部异常初始化 AbandonedMutexException 类的新实例。
AbandonedMutexException(String, Exception, Int32, WaitHandle)	用指定的错误信息、内部异常、被放弃的互斥体的索引（如果可用）以及表示该互斥体的 AbandonedMutexException 对象初始化 Mutex 类的新实例。
AbandonedMutexException(String, Int32, WaitHandle)	用指定的错误信息、被放弃的互斥体的索引（如果可用）以及被放弃的互斥体初始化 AbandonedMutexException 类的新实例。

属性

Data	获取键/值对的集合，这些键/值对提供有关该异常的其他用户定义信息。 (继承自 Exception)
HelpLink	获取或设置指向与此异常关联的帮助文件链接。 (继承自 Exception)
HResult	获取或设置 HRESULT（一个分配给特定异常的编码数字值）。 (继承自 Exception)
InnerException	获取导致当前异常的 Exception 实例。 (继承自 Exception)
Message	获取描述当前异常的消息。 (继承自 Exception)
Mutex	获取导致异常的被放弃的互斥体（如果已知的话）。
MutexIndex	获取导致异常的被放弃的互斥体的索引（如果已知的话）。
Source	获取或设置导致错误的应用程序或对象的名称。 (继承自 Exception)
StackTrace	获取调用堆栈上的即时框架字符串表示形式。 (继承自 Exception)
TargetSite	获取引发当前异常的方法。 (继承自 Exception)

方法

Equals(Object)	确定指定对象是否等于当前对象。 (继承自 Object)
GetBaseException()	当在派生类中重写时，返回 Exception，它是一个或多个并发的异常的根本原因。 (继承自 Exception)
GetHashCode()	作为默认哈希函数。 (继承自 Object)
GetObjectData(SerializationInfo, StreamingContext)	当在派生类中重写时，用关于异常的信息设置 SerializationInfo。 (继承自 Exception)
GetType()	获取当前实例的运行时类型。 (继承自 Exception)
MemberwiseClone()	创建当前 Object 的浅表副本。 (继承自 Object)
ToString()	创建并返回当前异常的字符串表示形式。 (继承自 Exception)

事件

SerializeObjectState

已过时。 当异常被序列化用来创建包含有关该异常的徐列出数据的异常状态对象时会出现该问题。 (继承自 Exception)

适用于

另请参阅

• Mutex
• Mutex