AbandonedMutexException Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.dll

Bütünleştirilmiş Kod:

mscorlib.dll

Bütünleştirilmiş Kod:

netstandard.dll

Bir iş parçacığı başka bir iş parçacığı serbest bırakmadan çıkarak terk ettiği bir Mutex nesne alırsa oluşan özel durum.

C#

public class AbandonedMutexException : Exception

C#

public class AbandonedMutexException : SystemException

C#

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

Devralma

Object

Exception

AbandonedMutexException

Devralma

Object

Exception

SystemException

AbandonedMutexException

Öznitelikler

ComVisibleAttribute SerializableAttribute

Örnekler

Aşağıdaki kod örneği, beş mutex'i terk eden bir iş parçacığı yürüterek , WaitAnyve WaitAll yöntemleri üzerindeki WaitOneetkilerini gösterir. Özelliğin MutexIndex değeri çağrı için WaitAny görüntülenir.

Not

yöntemine yapılan WaitAny çağrı, terk edilmiş mutexes biri tarafından kesilir. Diğer terk edilmiş mutex yine de sonraki bekleme yöntemleri tarafından bir AbandonedMutexException atılması neden olabilir.

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

Açıklamalar

İş parçacığı bir mutex'i terk ettiğinde, mutex'i alan sonraki iş parçacığında özel durum oluşturulur. İş parçacığı, zaten mutex üzerinde beklediğinden veya daha sonra mutex'e girdiği için mutex'i alabilir.

Terk edilmiş bir mutex ciddi bir programlama hatasına işaret eder. Bir iş parçacığı mutex serbest bırakılmadan çıktığında, mutex tarafından korunan veri yapıları tutarlı bir durumda olmayabilir. .NET Framework 2.0 sürümünden önce, bu tür sorunları bulmak zordu çünkü terk edilmiş bir mutex'in sonucu olarak bir bekleme tamamlandığında özel durum oluşturmadı. Daha fazla bilgi için sınıfına Mutex bakın.

Mutex'in sahipliğini istemek için bir sonraki iş parçacığı bu özel durumu işleyebilir ve veri yapılarının bütünlüğünün doğrulanması koşuluyla devam edebilir.

Oluşturucular

AbandonedMutexException()	AbandonedMutexException sınıfının yeni bir örneğini varsayılan değerlerle başlatır.
AbandonedMutexException(Int32, WaitHandle)	Sınıfın AbandonedMutexException yeni bir örneğini, varsa terk edilmiş mutex için belirtilen dizine ve mutex'i temsil eden bir Mutex nesneye başlatır.
AbandonedMutexException(SerializationInfo, StreamingContext)	AbandonedMutexException sınıfının yeni bir örneğini serileştirilmiş verilerle başlatır.
AbandonedMutexException(String)	Belirtilen hata iletisiyle sınıfının yeni bir örneğini AbandonedMutexException başlatır.
AbandonedMutexException(String, Exception)	Belirtilen hata iletisi ve iç özel durum ile sınıfının yeni bir örneğini AbandonedMutexException başlatır.
AbandonedMutexException(String, Exception, Int32, WaitHandle)	Sınıfın AbandonedMutexException yeni bir örneğini belirtilen bir hata iletisiyle, iç özel durumuyla, varsa terk edilmiş mutex diziniyle ve mutex'i temsil eden bir Mutex nesneyle başlatır.
AbandonedMutexException(String, Int32, WaitHandle)	Sınıfın AbandonedMutexException yeni bir örneğini belirtilen bir hata iletisiyle, varsa terk edilmiş mutex'in dizinini ve terk edilmiş mutex'i başlatır.

Özellikler

Data	Özel durum hakkında kullanıcı tanımlı ek bilgiler sağlayan bir anahtar/değer çifti koleksiyonu alır. (Devralındığı yer: Exception)
HelpLink	Bu özel durumla ilişkili yardım dosyasının bağlantısını alır veya ayarlar. (Devralındığı yer: Exception)
HResult	Belirli bir özel duruma atanan kodlanmış sayısal bir değer olan HRESULT'u alır veya ayarlar. (Devralındığı yer: Exception)
InnerException	Exception Geçerli özel duruma neden olan örneği alır. (Devralındığı yer: Exception)
Message	Geçerli özel durumu açıklayan bir ileti alır. (Devralındığı yer: Exception)
Mutex	Biliniyorsa özel duruma neden olan terk edilmiş mutex'i alır.
MutexIndex	Biliniyorsa özel duruma neden olan terk edilmiş mutex dizinini alır.
Source	Hataya neden olan uygulamanın veya nesnenin adını alır veya ayarlar. (Devralındığı yer: Exception)
StackTrace	Çağrı yığınındaki anlık çerçevelerin dize gösterimini alır. (Devralındığı yer: Exception)
TargetSite	Geçerli özel durumu oluşturan yöntemini alır. (Devralındığı yer: Exception)

Yöntemler

Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetBaseException()	Türetilmiş bir sınıfta geçersiz kılındığında, sonraki bir veya daha fazla özel durumun kök nedeni olan değerini döndürür Exception . (Devralındığı yer: Exception)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetObjectData(SerializationInfo, StreamingContext)	Türetilmiş bir sınıfta geçersiz kılındığında, özel durumla ilgili bilgilerle öğesini SerializationInfo ayarlar. (Devralındığı yer: Exception)
GetType()	Geçerli örneğin çalışma zamanı türünü alır. (Devralındığı yer: Exception)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
ToString()	Geçerli özel durumun dize gösterimini oluşturur ve döndürür. (Devralındığı yer: Exception)

Ekinlikler

SerializeObjectState

Geçersiz. Bir özel durum, özel durum hakkında serileştirilmiş veriler içeren bir özel durum nesnesi oluşturmak üzere seri hale getirildiğinde gerçekleşir. (Devralındığı yer: Exception)

Şunlara uygulanır

Ayrıca bkz.

• Mutex
• Mutex