Je dois créer une variable statique Thread-safe en C# .Net

Question

ok, c'est un peu plus compliqué que la question.

class A 
{ 
    static int needsToBeThreadSafe = 0; 

    public static void M1() 
    { 
    needsToBeThreadSafe = RandomNumber(); 
    } 

    public static void M2() 
    { 
    print(needsToBeThreadSafe); 
    } 
} 

maintenant je rechercherai qu'entre M1() et M2() appelle les séjours 'needsToBeThreadSafe' thread-safe.

Answer 1

Ce que vous pourriez essayer de demander est sur l'attribut [ThreadStatic]. Si vous voulez que chaque fil qui utilise la classe A d'avoir sa propre valeur séparée de needsToBeThreadSafe alors vous avez juste besoin de décorer ce champ avec l'attribut [ThreadStatic].

Pour plus d'informations, reportez-vous au MSDN documentation for ThreadStaticAttribute.

Answer 2

class A 
{ 
    static int needsToBeThreadSafe = 0; 
    static object statObjLocker = new object(); 

    public static void M1() 
    { 
     lock(statObjLocker) 
     { 
      needsToBeThreadSafe = RandomNumber(); 
     } 
    } 

    public static void M2() 
    { 
     lock(statObjLocker) 
     { 
      print(needsToBeThreadSafe); 
     } 
    } 
} 

Answer 3

Vous avez deux choix: le mot-clé est le plus facile volatile donné votre code présenté. déclarer needsToBeThreadSafe comme static volatile int et cela garantira que n'importe quel thread qui référence cette variable obtiendra la "dernière" copie, et la variable ne sera pas mise en cache dans votre code.

Cela dit, si vous voulez vous assurer que plus généralement M1() et M2() execute « atomiquement » (ou du moins exclusivement les uns des autres), alors vous voulez utiliser un lock. La syntaxe est propre avec un « bloc de verrouillage », comme ceci:

private static object locker = new Object(); 

//.. 

public static void M1() 
{ 
    lock(locker) 
    { 
     //..method body here 
    } 
} 

public static void M2() 
{ 
    lock(locker) 
    { 
     //..method body here 
    } 
} 

Quant à l'approche à adopter, qui est à vous et doivent être déterminées par le code. Si tout ce dont vous avez besoin est de vous assurer qu'une affectation de membre est propagée à tous les threads et n'est pas mise en cache, le mot-clé volatile est plus simple et fera l'affaire correctement. Si c'est au-delà, vous voudrez peut-être aller avec le lock.

Answer 4

Vous avez besoin d'un membre Volatile.

static volatile int needsToBeThreadSafe = 0; 

Answer 5

Vous pouvez également utiliser la ReaderWriterLockSlim, qui est plus efficace pour plusieurs lectures et moins écrit:

static int needsToBeThreadSafe = 0; 
static System.Threading.ReaderWriterLockSlim rwl = new System.Threading.ReaderWriterLockSlim(); 

public static void M1() 
{ 
    try 
    { 
     rwl.EnterWriteLock(); 
     needsToBeThreadSafe = RandomNumber(); 
    } 
    finally 
    { 
     rwl.ExitWriteLock(); 
    } 

} 

public static void M2() 
{ 
    try 
    { 
     rwl.EnterReadLock(); 
     print(needsToBeThreadSafe); 
    } 
    finally 
    { 
     rwl.ExitReadLock(); 
    } 
} 

Answer 6

Pour commencer, je suis d'accord avec les réponses en utilisant lock(), qui est le moyen le plus sûr.

Mais il existe une approche plus minimaliste, votre exemple de code ne montre que des déclarations simples à l'aide needsToBeThreadSafe et depuis int est atomique il vous suffit d'empêcher la mise en cache par le compilateur à l'aide volatile:

class A 
{ 
    static volatile int needsToBeThreadSafe = 0; 

} 

Mais si vous needToBeThreadSafe doit être 'ThreadSafe' sur plusieurs instructions, utilisez un verrou.

Answer 7

Comment A propos:

public static void M1() 
{ 
    Interlocked.Exchange(ref needsToBeThreadSafe, RandomNumber()); 
} 

public static void M2() 
{ 
    print(Interlocked.Read(ref needsToBeThreadSafe)); 
}