Compteur c # Thread safe fast (est)
Quel est le moyen d'obtenir un compteur thread safe en C# avec les meilleures performances possibles?
C'est aussi simple que possible:
public static long GetNextValue()
{
long result;
lock (LOCK)
{
result = COUNTER++;
}
return result;
}
Mais existe-t-il des alternatives plus rapides?
4 réponses
Comme recommandé par d'autres, le Interlocked.Increment aura de meilleures performances que lock(). Il suffit de jeter un oeil à L'IL et à L'assemblage où vous verrez que Increment se transforme en une instruction "bus lock" et que sa variable est directement incrémentée (x86) ou "ajoutée" à (x64).
Cette instruction "bus lock" verrouille le bus pour empêcher un autre processeur d'accéder au bus pendant que le processeur appelant effectue son fonctionnement. Maintenant, jetez un oeil à L'IL de la déclaration C# lock(). Ici, vous verrez des appels à Monitor pour commencer ou terminer une section.
En d'autres termes, l'instruction.Net lock() fait beaucoup plus que le. Net Interlocked.Increment.
DONC, si tout ce que vous voulez faire est d'incrémenter une variable, Interlock.Increment sera plus rapide. Passez en revue toutes les méthodes verrouillées pour voir les différentes opérations atomiques disponibles et pour trouver celles qui répondent à vos besoins. Utilisez lock() lorsque vous voulez faire des choses plus complexes comme plusieurs incréments/décrémentations interreliés, ou pour sérialiser l'accès à des ressources plus complexes que entier.
Je vous suggère d'utiliser l'incrément de verrouillage intégré de. net dans le système.Bibliothèque de Threading.
Le code suivant incrémentera une variable longue par référence et est complètement thread safe:
Interlocked.Increment(ref myNum);
Source: http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx