Monitoraggio vs blocco

Quando è appropriato utilizzare la Monitorclasse o la lockparola chiave per la sicurezza dei thread in C #?

EDIT: Dalle risposte finora sembra che locksia breve per una serie di chiamate alla Monitorclasse. A cosa serve esattamente la chiamata di blocco? O più esplicitamente,

class LockVsMonitor
{
    private readonly object LockObject = new object();
    public void DoThreadSafeSomethingWithLock(Action action)
    {
        lock (LockObject)
        {
            action.Invoke();
        }
    }
    public void DoThreadSafeSomethingWithMonitor(Action action)
    {
        // What goes here ?
    }
}

Aggiornare

Grazie a tutti per il vostro aiuto: ho pubblicato un'altra domanda come seguito ad alcune delle informazioni che avete fornito. Dato che sembri essere esperto in questo settore, ho pubblicato il link: Cosa c'è di sbagliato in questa soluzione per bloccare e gestire le eccezioni bloccate?

Eric Lippert ne parla nel suo blog: serrature ed eccezioni non si mescolano

Il codice equivalente è diverso tra C # 4.0 e le versioni precedenti.

In C # 4.0 è:

bool lockWasTaken = false;
var temp = obj;
try
{
    Monitor.Enter(temp, ref lockWasTaken);
    { body }
}
finally
{
    if (lockWasTaken) Monitor.Exit(temp);
}

Si basa sull'impostazione Monitor.Enteratomica della bandiera quando viene preso il blocco.

E prima era:

var temp = obj;
Monitor.Enter(temp);
try
{
   body
}
finally
{
    Monitor.Exit(temp);
}

Ciò non si basa sul fatto che venga generata alcuna eccezione tra Monitor.Entere try. Penso che nel codice di debug questa condizione sia stata violata perché il compilatore ha inserito un NOP tra di loro e quindi ha reso possibile l'aborto del thread tra quelli possibili.

lockè solo una scorciatoia per Monitor.Entercon try+ finallye Monitor.Exit. Usa l'istruzione lock ogni volta che è sufficiente: se hai bisogno di qualcosa come TryEnter, dovrai usare Monitor.

Un'istruzione lock è equivalente a:

Monitor.Enter(object);
try
{
   // Your code here...
}
finally
{
   Monitor.Exit(object);
}

Tuttavia, tieni presente che Monitor può anche Wait () e Pulse () , che sono spesso utili in complesse situazioni di multithreading.

Aggiornare

Tuttavia in C # 4 è implementato in modo diverso:

bool lockWasTaken = false;
var temp = obj;
try 
{
     Monitor.Enter(temp, ref lockWasTaken); 
     //your code
}
finally 
{ 
     if (lockWasTaken) 
             Monitor.Exit(temp); 
} 

Grazie a CodeInChaos per commenti e collegamenti

Monitorè più flessibile. Il mio caso d'uso preferito dell'utilizzo del monitor è quando non vuoi aspettare il tuo turno e saltare semplicemente :

//already executing? forget it, lets move on
if(Monitor.TryEnter(_lockObject))
{
    //do stuff;
    Monitor.Exit(_lockObject);
}

Come altri hanno già detto, lockè "equivalente" a

Monitor.Enter(object);
try
{
   // Your code here...
}
finally
{
   Monitor.Exit(object);
}

Ma solo per curiosità, lockconserverà il primo riferimento che gli passi e non lo getterà se lo cambi. So che non è consigliabile cambiare l'oggetto bloccato e tu non vuoi farlo.

Ma ancora una volta, per la scienza, funziona bene:

var lockObject = "";
var tasks = new List<Task>();
for (var i = 0; i < 10; i++)
    tasks.Add(Task.Run(() =>
    {
        Thread.Sleep(250);
        lock (lockObject)
        {
            lockObject += "x";
        }
    }));
Task.WaitAll(tasks.ToArray());

... E questo non:

var lockObject = "";
var tasks = new List<Task>();
for (var i = 0; i < 10; i++)
    tasks.Add(Task.Run(() =>
    {
        Thread.Sleep(250);
        Monitor.Enter(lockObject);
        try
        {
            lockObject += "x";
        }
        finally
        {
            Monitor.Exit(lockObject);
        }
    }));
Task.WaitAll(tasks.ToArray());

Errore:

Si è verificata un'eccezione di tipo "System.Threading.SynchronizationLockException" in 70783sTUDIES.exe ma non è stata gestita nel codice utente

Informazioni aggiuntive: il metodo di sincronizzazione degli oggetti è stato chiamato da un blocco di codice non sincronizzato.

Questo perchè Monitor.Exit(lockObject);agirà su lockObjectquale è cambiato perchè stringssono immutabili, quindi lo stai chiamando da un blocco di codice non sincronizzato .. ma comunque. Questo è solo un fatto divertente.

Entrambi sono la stessa cosa. lock è una parola chiave c sharp e usa la classe Monitor.

http://msdn.microsoft.com/en-us/library/ms173179(v=vs.80).aspx

Il blocco e il comportamento di base del monitor (invio + uscita) è più o meno lo stesso, ma il monitor ha più opzioni che ti consentono più possibilità di sincronizzazione.

Il lucchetto è una scorciatoia ed è l'opzione per l'utilizzo di base.

Se hai bisogno di più controllo, il monitor è l'opzione migliore. Puoi usare Wait, TryEnter e Pulse, per usi avanzati (come barriere, semafori e così via).

La parola chiave Lock Lock garantisce che un thread stia eseguendo un pezzo di codice alla volta.

lock (lockObject)

        {
        //   Body
        }

La parola chiave lock contrassegna un blocco di istruzioni come sezione critica ottenendo il blocco di mutua esclusione per un dato oggetto, eseguendo un'istruzione e quindi rilasciando il blocco

Se un altro thread tenta di inserire un codice bloccato, attenderà, si bloccherà, fino al rilascio dell'oggetto.

Monitor Il Monitor è una classe statica e appartiene allo spazio dei nomi System.Threading.

Fornisce un blocco esclusivo sull'oggetto in modo che un solo thread possa entrare nella sezione critica in un dato momento.

Differenza tra monitoraggio e blocco in C #

Il lucchetto è la scorciatoia per Monitor.Entra con try e infine. Blocca le maniglie prova e infine blocca internamente Blocca = Controlla + prova finalmente.

Se si desidera un maggiore controllo per implementare soluzioni avanzate utilizzando multithreading TryEnter() Wait(), Pulse()ePulseAll() metodi, allora la classe Monitor è la vostra opzione.

C # Monitor.wait(): un thread attende la notifica di altri thread.

Monitor.pulse(): Un thread notifica a un altro thread.

Monitor.pulseAll(): Un thread notifica tutti gli altri thread all'interno di un processo

Oltre a tutte le spiegazioni precedenti, lock è un'istruzione C # mentre Monitor è una classe di .NET situata nello spazio dei nomi System.Threading.