Mutex.ReleaseMutex-Methode
Gibt das Mutex einmal frei.
Namespace: System.Threading
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public Sub ReleaseMutex
'Usage
Dim instance As Mutex
instance.ReleaseMutex
public void ReleaseMutex ()
public:
void ReleaseMutex ()
public void ReleaseMutex ()
public function ReleaseMutex ()
Ausnahmen
| Ausnahmetyp | Bedingung |
|---|---|
Der aufrufende Thread ist nicht im Besitz des Mutex. |
Hinweise
Ein Thread, der einen Mutex besitzt, kann denselben Mutex bei wiederholten Aufrufen von Wartefunktionen angeben, ohne dass seine Ausführung blockiert wird. Die Anzahl der Aufrufe wird von der Common Language Runtime gespeichert. Der Thread muss ReleaseMutex ebenso so oft aufrufen, um den Besitz des Mutex wieder aufzuheben.
Wenn ein Thread beendet wird, während er einen Mutex besitzt, wird der Mutex abgebrochen. Der Zustand des Mutex wird auf signalisiert festgelegt, und der nächste Thread in der Warteschlange übernimmt den Besitz. Wenn kein Besitzer des Mutex bestimmt werden kann, ist der Zustand des Mutex signalisiert. Ab Version 2.0 von .NET Framework wird eine AbandonedMutexException im nächsten Thread ausgelöst, der den Mutex erhält. Vor Version 2.0 von .NET Framework wurde keine Ausnahme ausgelöst.
Warnung
Ein abgebrochener Mutex gibt einen schwerwiegenden Fehler im Code an. Wenn ein Thread beendet wird, ohne dass der Mutex freigegeben wird, ist der Zustand der vom Mutex geschützten Datenstrukturen möglicherweise nicht konsistent. Der nächste Thread, der den Besitz des Mutex anfordert, kann diese Ausnahme verarbeiten und fortfahren, wenn die Integrität der Datenstrukturen bestätigt werden kann.
Beispiel
' This example shows how a Mutex is used to synchronize access
' to a protected resource. Unlike Monitor, Mutex can be used with
' WaitHandle.WaitAll and WaitAny, and can be passed across
' AppDomain boundaries.
Imports System
Imports System.Threading
Imports Microsoft.VisualBasic
Class Test
' Create a new Mutex. The creating thread does not own the
' Mutex.
Private Shared mut As New Mutex()
Private Const numIterations As Integer = 1
Private Const numThreads As Integer = 3
<MTAThread> _
Shared Sub Main()
' Create the threads that will use the protected resource.
Dim i As Integer
For i = 1 To numThreads
Dim myThread As New Thread(AddressOf MyThreadProc)
myThread.Name = [String].Format("Thread{0}", i)
myThread.Start()
Next i
' The main thread exits, but the application continues to
' run until all foreground threads have exited.
End Sub 'Main
Private Shared Sub MyThreadProc()
Dim i As Integer
For i = 1 To numIterations
UseResource()
Next i
End Sub 'MyThreadProc
' This method represents a resource that must be synchronized
' so that only one thread at a time can enter.
Private Shared Sub UseResource()
' Wait until it is safe to enter.
mut.WaitOne()
Console.WriteLine("{0} has entered protected area", _
Thread.CurrentThread.Name)
' Place code to access non-reentrant resources here.
' Simulate some work
Thread.Sleep(500)
Console.WriteLine("{0} is leaving protected area" & vbCrLf, _
Thread.CurrentThread.Name)
' Release Mutex.
mut.ReleaseMutex()
End Sub 'UseResource
End Class 'MyMainClass
// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.
using System;
using System.Threading;
class Test
{
// Create a new Mutex. The creating thread does not own the
// Mutex.
private static Mutex mut = new Mutex();
private const int numIterations = 1;
private const int numThreads = 3;
static void Main()
{
// Create the threads that will use the protected resource.
for(int i = 0; i < numThreads; i++)
{
Thread myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.Name = String.Format("Thread{0}", i + 1);
myThread.Start();
}
// The main thread exits, but the application continues to
// run until all foreground threads have exited.
}
private static void MyThreadProc()
{
for(int i = 0; i < numIterations; i++)
{
UseResource();
}
}
// This method represents a resource that must be synchronized
// so that only one thread at a time can enter.
private static void UseResource()
{
// Wait until it is safe to enter.
mut.WaitOne();
Console.WriteLine("{0} has entered the protected area",
Thread.CurrentThread.Name);
// Place code to access non-reentrant resources here.
// Simulate some work.
Thread.Sleep(500);
Console.WriteLine("{0} is leaving the protected area\r\n",
Thread.CurrentThread.Name);
// Release the Mutex.
mut.ReleaseMutex();
}
}
// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.
using namespace System;
using namespace System::Threading;
const int numIterations = 1;
const int numThreads = 3;
ref class Test
{
public:
// Create a new Mutex. The creating thread does not own the
// Mutex.
static Mutex^ mut = gcnew Mutex;
static void MyThreadProc()
{
for ( int i = 0; i < numIterations; i++ )
{
UseResource();
}
}
private:
// This method represents a resource that must be synchronized
// so that only one thread at a time can enter.
static void UseResource()
{
//Wait until it is OK to enter.
mut->WaitOne();
Console::WriteLine( "{0} has entered protected the area", Thread::CurrentThread->Name );
// Place code to access non-reentrant resources here.
// Simulate some work.
Thread::Sleep( 500 );
Console::WriteLine( "{0} is leaving protected the area\r\n", Thread::CurrentThread->Name );
// Release the Mutex.
mut->ReleaseMutex();
}
};
int main()
{
// Create the threads that will use the protected resource.
for ( int i = 0; i < numThreads; i++ )
{
Thread^ myThread = gcnew Thread( gcnew ThreadStart( Test::MyThreadProc ) );
myThread->Name = String::Format( "Thread {0}", i + 1 );
myThread->Start();
}
// The main thread exits, but the application continues to
// run until all foreground threads have exited.
}
// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.
import System.*;
import System.Threading.*;
import System.Threading.Thread;
class Test
{
// Create a new Mutex. The creating thread does not own the
// Mutex.
private static Mutex mut = new Mutex();
private static int numIterations = 1;
private static int numThreads = 3;
public static void main(String[] args)
{
// Create the threads that will use the protected resource.
for (int i = 0; i < numThreads; i++) {
Thread myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.set_Name(String.Format("Thread{0}",
String.valueOf(i + 1)));
myThread.Start();
}
} //main
// The main thread exits, but the application continues to
// run until all foreground threads have exited.
private static void MyThreadProc()
{
for (int i = 0; i < numIterations; i++) {
UseResource();
}
} //MyThreadProc
// This method represents a resource that must be synchronized
// so that only one thread at a time can enter.
private static void UseResource()
{
// Wait until it is safe to enter.
mut.WaitOne();
Console.WriteLine("{0} has entered the protected area",
Thread.get_CurrentThread().get_Name());
// Place code to access non-reentrant resources here.
// Simulate some work.
Thread.Sleep(500);
Console.WriteLine("{0} is leaving the protected area\r\n",
Thread.get_CurrentThread().get_Name());
// Release the Mutex.
mut.ReleaseMutex();
} //UseResource
} //Test
Plattformen
Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
Mutex-Klasse
Mutex-Member
System.Threading-Namespace