Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Classe Mutex

Classe Mutex

Primitiva di sincronizzazione che può essere utilizzata anche per la sincronizzazione interprocesso.

Spazio dei nomi: System.Threading
Assembly: mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)] 
public sealed class Mutex : WaitHandle
/** @attribute ComVisibleAttribute(true) */ 
public final class Mutex extends WaitHandle
ComVisibleAttribute(true) 
public final class Mutex extends WaitHandle

NotaNota

L'attributo HostProtectionAttribute applicato a questa classe dispone del valore della proprietà Resources seguente: Synchronization. ExternalThreading. L'oggetto HostProtectionAttribute non influisce sulle applicazioni desktop, che in genere sono avviate facendo doppio clic sull'icona,digitando un comando oppure immettendo un URL in un browser. Per ulteriori informazioni, vedere la classe HostProtectionAttribute oppure Programmazione per SQL Server e attributi di protezione host.

Quando due o più thread devono accedere contemporaneamente a una risorsa condivisa, il sistema necessita di un meccanismo di sincronizzazione per assicurare che solo un thread alla volta utilizzi tale risorsa. L'oggetto Mutex è una primitiva di sincronizzazione che concede a un solo thread l'accesso esclusivo alla risorsa condivisa. Se un mutex è acquisito da un thread, il secondo thread che intende acquisirlo viene sospeso finché il mutex non viene rilasciato dal primo thread.

Per richiedere la proprietà di un mutex, è possibile utilizzare il metodo WaitHandle.WaitOne. Un mutex di proprietà di un thread può essere richiesto da quest'ultimo in chiamate successive a WaitOne senza interrompere l'esecuzione. Sarà tuttavia necessario chiamare il metodo ReleaseMutex per lo stesso numero di volte per rilasciare la proprietà del mutex. La classe Mutex impone l'identità del thread, in modo che un mutex possa essere rilasciato solo dal thread che lo ha acquisito. L'identità del thread non viene invece imposta dalla classe Semaphore.

Se un thread viene terminato mentre ha la proprietà di un mutex, quest'ultimo viene considerato abbandonato. Lo stato del mutex viene impostato su segnalato e il successivo thread in attesa ottiene la proprietà. Se nessuno ha la proprietà del mutex, il suo stato è segnalato. A partire dalla versione 2.0 di .NET Framework, nel thread successivo che acquisisce il mutex viene generata un'eccezione AbandonedMutexException. Nelle versioni di .NET Framework precedenti alla 2.0 non viene generata alcuna eccezione.

Nota di avvisoAttenzione

Un mutex abbandonato indica un errore grave nel codice. Se un thread si chiude senza rilasciare il mutex, è possibile che lo stato delle strutture di dati protette da tale mutex non sia uniforme. Il thread successivo che richiede la proprietà del mutex può gestire tale eccezione e procedere, a condizione che sia possibile verificare l'integrità delle strutture di dati.

Sono disponibili due tipi di mutex, locali e di sistema denominati. Se si crea un oggetto Mutex utilizzando un costruttore che accetta un nome, questo viene associato a un oggetto del sistema operativo con tale nome. I mutex di sistema denominati risultano visibili attraverso il sistema operativo e possono essere utilizzati per sincronizzare le attività dei processi. È possibile creare più oggetti Mutex che rappresentano lo stesso mutex di sistema denominato e utilizzare il metodo OpenExisting per aprire un mutex di sistema denominato esistente.

I mutex locali esistono solo all'interno dei processi e possono essere utilizzati da qualsiasi thread del processo che disponga di un riferimento all'oggetto Mutex locale. Ogni oggetto Mutex rappresenta un mutex locale distinto.

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

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

Questo tipo è protetto per operazioni multithread.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

Supportato in: 2.0 1.1 1.0

.NET Compact Framework

Supportato in: 2.0 1.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft