Comment fonctionne le verrouillage exactement?

Je vois que pour utiliser des objets qui ne sont pas sûrs pour les threads, nous enveloppons le code avec un verrou comme ceci:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

Que se passe-t-il donc lorsque plusieurs threads accèdent au même code (supposons qu'il s'exécute dans une application Web ASP.NET). Sont-ils en file d'attente? Si oui, combien de temps attendront-ils?

Quel est l'impact sur les performances en raison de l'utilisation de verrous?

L' lockinstruction est traduite par C # 3.0 comme suit:

var temp = obj;

Monitor.Enter(temp);

try
{
    // body
}
finally
{
    Monitor.Exit(temp);
}

En C # 4.0, cela a changé et il est maintenant généré comme suit:

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

Vous pouvez trouver plus d'informations sur ce qui se Monitor.Enterpasse ici . Pour citer MSDN:

Permet Enterd'acquérir le moniteur sur l'objet passé en paramètre. Si un autre thread a exécuté un Enter sur l'objet mais n'a pas encore exécuté le correspondant Exit, le thread actuel se bloquera jusqu'à ce que l'autre thread libère l'objet. Il est légal que le même thread invoque Enterplus d'une fois sans le bloquer; cependant, un nombre égal d' Exitappels doit être invoqué avant que d'autres threads en attente sur l'objet se débloquent.

La Monitor.Enterméthode attendra infiniment; il n'expirera pas .

C'est plus simple que vous ne le pensez.

Selon Microsoft : le lockmot clé garantit qu'un thread n'entre pas dans une section critique de code tandis qu'un autre thread se trouve dans la section critique. Si un autre thread essaie d'entrer un code verrouillé, il attendra, bloquera, jusqu'à ce que l'objet soit libéré.

Le lockmot-clé appelle Enterau début du bloc et Exità la fin du bloc. lockLe mot clé gère en fait la Monitorclasse à l'arrière-plan.

Par exemple:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

Dans le code ci-dessus, le thread entre d'abord dans une section critique, puis il se verrouille obj. Lorsqu'un autre thread essaie d'entrer, il essaiera également de se verrouiller obj, qui est déjà verrouillé par le premier thread. Le deuxième thread devra attendre la libération du premier thread obj. Lorsque le premier fil sort, un autre fil se verrouille objet entre dans la section critique.

Non, ils ne sont pas en file d'attente, ils dorment

Une déclaration de verrouillage du formulaire

lock (x) ... 

où x est une expression d'un type de référence, équivaut précisément à

var temp = x;
System.Threading.Monitor.Enter(temp); 
try { ... } 
finally { System.Threading.Monitor.Exit(temp); }

Vous avez juste besoin de savoir qu'ils attendent les uns des autres, et qu'un seul thread entrera pour verrouiller le bloc, les autres attendront ...

Le moniteur est entièrement écrit en .net donc c'est assez rapide, regardez aussi la classe Moniteur avec réflecteur pour plus de détails

Les verrous empêcheront les autres threads d'exécuter le code contenu dans le bloc de verrouillage. Les threads devront attendre que le thread à l'intérieur du bloc de verrouillage soit terminé et que le verrouillage soit libéré. Cela a un impact négatif sur les performances dans un environnement multithread. Si vous devez le faire, vous devez vous assurer que le code dans le bloc de verrouillage peut être traité très rapidement. Vous devriez essayer d'éviter des activités coûteuses comme l'accès à une base de données, etc.

L'impact sur les performances dépend de la façon dont vous verrouillez. Vous pouvez trouver une bonne liste d'optimisations ici: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

Fondamentalement, vous devriez essayer de verrouiller le moins possible, car cela met votre code d'attente en veille. Si vous avez des calculs lourds ou du code de longue durée (par exemple, le téléchargement de fichiers) dans un verrou, cela entraîne une énorme perte de performances.

La partie de l'instruction lock ne peut être exécutée que par un seul thread, donc tous les autres threads l'attendront indéfiniment, le thread qui détient le verrou se termine. Cela peut entraîner un soi-disant blocage.

L' lockinstruction est traduite en appels aux méthodes Enteret .ExitMonitor

L' lockinstruction attendra indéfiniment que l'objet de verrouillage soit libéré.

le verrou est en fait la classe Monitor cachée .