Incrément non signé C# multi-threadé

Question

Je souhaite incrémenter un entier non signé à partir de plusieurs threads.

Je connais Interlocked.Increment, mais il ne gère pas les entiers non signés. Je pourrais utiliser lock(), mais je ne le ferais pas si possible pour des raisons de performances.

Est-ce que le thread est sûr juste pour l'incrémenter normalement? Peu importe si l'incrément occasionnel a été perdu, car il n'est utilisé que pour les statistiques. Ce que je ne veux pas, c'est la valeur d'être corrompu.

Answer 1

vous pouvez déclarer l'uint comme volatile.

http://msdn.microsoft.com/en-us/library/x13ttww7(VS.71).aspx

Answer 2

Si vous avez vraiment besoin de la gamme complète d'un unsigned int (2^32-1) au lieu d'un int signé (2^31 -1), vous pourriez lancer un int64 (il y a un Interlocked.Increment surcharge qui prend int64), puis renvoyé vers un int non signé.

Answer 3

Vous dites que vous ne voulez pas utiliser lock pour des raisons de performances - mais l'avez-vous testé? Un verrou incontesté (ce qui est susceptible d'être, par les sons de celui-ci) est assez bon marché.

Je préfère généralement "évidemment correct" plutôt que "intelligent et peut-être plus performant" quand il s'agit de filetage (et en général, mais surtout pour le filetage). Benchmark votre application avec et sans verrouillage, et voir si vous pouvez même remarquer la différence. Si le verrouillage fait différence significative puis sûr, utilisez des trucs astucieux. Sinon, je resterais avec un verrou.

Une chose que vous pourriez vouloir faire est d'utiliser Interlocked.Increment avec un int et juste jeter lorsqu'il est nécessaire d'obtenir un uint, comme ceci:

using System; 
using System.Reflection; 
using System.Threading; 

public class Test 
{ 
    private static int count = int.MaxValue-1; 

    public static uint IncrementCount() 
    { 
     int newValue = Interlocked.Increment(ref count); 
     return (uint) newValue; 
    } 

    public static void Main() 
    { 
     Console.WriteLine(IncrementCount()); 
     Console.WriteLine(IncrementCount()); 
     Console.WriteLine(IncrementCount()); 
    } 

} 

Sortie:

2147483647 
2147483648 
2147483649 

(En d'autres termes, il s'enroule sans aucun problème.)