Ho bisogno di creare una variabile statica thread-safe in C# .Net

Question

ok, è un po 'più complicato della domanda.

class A 
{ 
    static int needsToBeThreadSafe = 0; 

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

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

ora ho bisogno che tra M1() e M2() chiama soggiorni 'needsToBeThreadSafe' thread-safe.

Answer 1

Che cosa si potrebbe tentare di chiedere è la [ThreadStatic] attributo. Se si desidera che ogni thread che utilizza la classe A di avere un proprio valore separata di needsToBeThreadSafe allora non vi resta che decorare quel campo con il [ThreadStatic] attributo.

Per ulteriori informazioni, fare riferimento allo 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

Avete due scelte: il più facile dato il vostro codice presentato è la parola chiave volatile. dichiarare needsToBeThreadSafe come static volatile int e ciò garantirà che qualsiasi thread che fa riferimento a tale variabile riceverà la copia "più recente" e la variabile non verrà memorizzata nella cache all'interno del codice.

Detto questo, se si vuole garantire più in generale che M1() e M2() eseguire "atomico" (o almeno esclusivamente l'uno dall'altro), poi si desidera utilizzare un lock. La sintassi è più pulita con un "blocco di blocco", in questo modo:

private static object locker = new Object(); 

//.. 

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

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

Come al quale approccio adottare, che sta a voi e dovrebbe essere determinata dal codice. Se tutto ciò di cui hai bisogno è garantire che l'assegnazione di un membro venga propagata a tutti i thread e non sia memorizzata nella cache, la parola chiave volatile è più semplice e farà bene il lavoro. Se è oltre questo, potresti voler andare con lo lock.

Answer 4

Suono come se fosse necessario un membro Volatile.

static volatile int needsToBeThreadSafe = 0; 

Answer 5

È inoltre possibile utilizzare il ReaderWriterLockSlim, che è più efficiente per più letture e meno scrive:

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

Per cominciare sono d'accordo con le risposte utilizzando lock(), che è il modo più sicuro.

Ma esiste un approccio più minimalista, il codice di esempio mostra solo le dichiarazioni singole utilizzando needsToBeThreadSafe e dal int è atomico è sufficiente per impedire la memorizzazione nella cache dal compilatore utilizzando volatile:

class A 
{ 
    static volatile int needsToBeThreadSafe = 0; 

} 

Ma se si serve needToBeThreadSafe per essere 'ThreadSafe' su più istruzioni, utilizzare un lock.

Answer 7

Come su:

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

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